BUUOJ Misc

Misc

金三胖

Photoshop 打开后调出时间轴，可见三张图。

flag{he11ohongke}

二维码

binwalk 一下发现文件末尾有压缩包，binwalk -e 提取出来。

根据 4 number 的提示，使用 ARCHPR 爆破压缩包密码。

得到密码为 7639，解压得到 flag。

CTF{vjpw_wnoei}

N种方法解决

没法正常运行的 exe 文件，010 editor 打开，发现只是一张 base64 的图片。

解码之后得到一个二维码。

扫码得 flag。

KEY{dca57f966e4e4e31fd5b15417da63269}

大白

用 010 editor 打开图片，运行模板发现 CRC 校验错误，猜测是图片宽高被修改。用脚本跑出宽高。

crcbp = open("dabai.png", "rb").read()
for i in range(2000):
    for j in range(2000):
        data = crcbp[12:16] + struct.pack('>i', i)+struct.pack('>i', j)+crcbp[24:29]
        crc32 = binascii.crc32(data) & 0xffffffff
        if(crc32 == 0x6D7C7135):
            print(i, j)
            print('hex:', hex(i), hex(j))

得到高度应为 01 DF，对应修改得到原图。

flag{Heql0_d4_ba1}

你竟然赶我走

用 010 editor 打开图片可发现文件的末尾有 flag。

flag{stego_is_s0_bor1ing}

基础破解

根据题目描述可知压缩包的密码为四位数字。ARCHPR 爆破得到密码 2563。

解压可得到一串 base64。

ZmxhZ3s3MDM1NDMwMGE1MTAwYmE3ODA2ODgwNTY2MWI5M2E1Y30=

解码可得到 flag。

flag{70354300a5100ba78068805661b93a5c}

乌镇峰会种图

用 010 editor 打开图片可发现文件的末尾有 flag。

flag{97314e7864a8f62627b26f3f998c37f1}

LSB

使用 StegSolve 解得 LSB 下存在 PNG 文件。

提取出来得到一个二维码，扫描之后得到 flag。

cumtctf{1sb_i4_s0_Ea4y}

图片中的秘密

用 010 editor 打开文件，在数据帧中可以找到 flag.

flag{870c5a72806115cb5439345d8b014396}

rar

根据题目描述可知压缩包的密码为四位数字。ARCHPR 爆破得到密码 8795。

解压可得到 flag。

flag{1773c5da790bd3caff38e3decd180eb7}

wireshark

使用 wireshark 打开流量包，筛选 http 条目。根据提示可知要找管理员密码。找到登录的 POST 请求，可以看到管理员密码。

flag{ffb7567a1d4f4abdffdb54e022f8facd}

qr

扫描二维码得出 flag。

Flag{878865ce73370a4ce607d21ca01b5e59}

zip伪加密

010 editor 打开文件，修改 frFlags 和 deFlags为 00 即可去除伪加密。

解压即可得到 flag。

flag{Adm1N-B2G-kU-SZIP}

ningen

010 editor 查看文件可知文件尾部有压缩文件。

binwalk -e 分理出压缩包，根据题目描述猜测为四位数密码，用 ARCHPR 爆破得出解压密码为 8368。

解压出文件可得 flag。

flag{b025fc9ca797a67d2103bfbc407a6d5f}

镜子里面的世界

StegSolve 解 LSB 隐写可得信息。

提取出来可得 flag。

flag{st3g0_saurus_wr3cks}

被嗅探的流量

wireshark 分析流量包，筛选 http 条目可看到一个图片的 POST。

提取出分组字节，用 010 editor 打开，可在文件尾部看到 flag。

flag{da73d88936010da1eeeb36e945ec4b97}

小明的保险箱

010 editor 打开文件，文件尾部发现压缩文档。binwalk -e 分离出来。

根据题目描述可知压缩包的密码为四位数字。ARCHPR 爆破得到密码 7869。

解压出文件可得 flag。

flag{75a3d68bf071ee188c418ea6cf0bb043}

爱因斯坦

010 editor 打开解压的图片，文件尾部可以发现压缩文档。binwalk -e 分离出来。

发现需要解压密码，同时在图片的备注中有 this_is_not_password。

将其作为解压密码成功解压文件，即可得到 flag。

flag{dd22a92bf2cceb6c0cd0d6b83ff51606}

easycap

Wireshark 打开流量包，发现全是 TCP 流，于是追踪 TCP 流，可得 flag。

flag{385b87afc8671dee07550290d16a8071}

另外一个世界

010 editor 打开文件，模板报错 Missing End of File marker，发现文件尾部有数据。

01101011011011110110010101101011011010100011001101110011

将其写作八位一组之后转 ASCII 可得 koekj3s。

flag{koekj3s}

FLAG

StegSolve 解 LSB 隐写可发现一个压缩文件。

保存下来并去掉末尾的冗余数据，解压得到一个 ELF 文件。使用 Linux 终端运行可得 flag。

hctf{dd0gf4c3tok3yb0ard4g41n~~~}

隐藏的钥匙

010 editor 打开文件可见 flag 提示。

提取出来之后 base64 解码可得 flag。

flag{377cbadda1eca2f2f73d36277781f00a}

假如给我三天光明

图片中的盲文根据对照表解出为 kmdonowg。将其作为压缩包密码解密音频文件。

解压音频后可甄别是摩斯电码，使用 CwGet 接收可得文本。

flag{wpei08732?23dz}

神秘龙卷风

根据题目描述可知压缩包的密码为四位数字。ARCHPR 爆破得到密码 5463。

解压出来发现一个文本，使用 Brainfuck 解码之后得到 flag。

flag{e4bbef8bdf9743f8bf5b727a9f6332a8}

后门查杀

下载代码下来审计，发现如下一行。$pass = '6ac45fb83b3bc355c024f5034b947dd3'; //angel 直接取出字符串得到 flag。

flag{6ac45fb83b3bc355c024f5034b947dd3}

荷兰宽带数据泄露

.bin 文件，猜测是路由器配置文件。使用 RouterPassView 查看，尝试之后发现用户名字段为 flag。

flag{053700357621}

来首歌吧

打开音频文件，发现中间夹杂着莫斯电码，使用 CwGet 接收，得到 flag。

图上第一个字符有误，音频中为 ..... 应为 5。

flag{5BC925649CB0188F52E617D70929191C}

数据包中的线索

Wireshark 分析数据包，追踪 TCP 流，可以发现 base64 数据。

将其前后冗余数据去除后加上 data:image/jpeg;base64, 可以解码成图片，从而得到 flag。

flag{209acebf6324a09671abc31c869de72c}

九连环

010 editor 打开文件，发现其尾部有压缩文档。

binwalk -e 分离出来，得到套娃的两个压缩文件。第二层的图片被加密了，找不到其他信息，猜测是伪加密。修改 14 00 01 08 为 14 00 00 08 成功解压出图片。

然后 jpg 图片看隐写，StegHide 成功解出 secret，得到第三层压缩包密码 bV1g6t5wZDJif^J7。

解压即可得到 flag。

flag{1RTo8w@&4nK@z*XL}

面具下的flag

010 editor 打开文件，发现其尾部有压缩文档。

binwalk -e 分离出来，得到一个加密的压缩文档。分析之后可知是伪加密，修正之后解压得到虚拟磁盘文件。使用 7z x flag.vmdk 解压并重命名 NUL 文件之后可以得到两端文本。

+++++ +++++ [->++ +++++ +++<] >++.+ +++++ .<+++ [->-- -<]>- -.+++ +++.<
++++[ ->+++ +<]>+ +++.< +++++ +[->- ----- <]>-- ----- --.<+ +++[- >----
<]>-- ----- .<+++ [->++ +<]>+ +++++ .<+++ +[->- ---<] >-.<+ +++++ [->++
++++< ]>+++ +++.< +++++ [->-- ---<] >---- -.+++ .<+++ [->-- -<]>- ----- .<
Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.
Ook. Ook. Ook. Ook! Ook? Ook! Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook.
Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook?
Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.
Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.
Ook. Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook! Ook!
Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook.
Ook. Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.
Ook. Ook. Ook. Ook. Ook! Ook? Ook! Ook! Ook. Ook? Ook! Ook! Ook! Ook! Ook!
Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook? Ook. Ook? Ook! Ook. Ook?
Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook.
Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook! Ook! Ook. Ook? Ook. Ook.
Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook? Ook! Ook.
Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook.
Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook!
Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook! Ook! Ook. Ook?
Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook. Ook.
Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook! Ook! Ook! Ook!
Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook! Ook. Ook?
Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook! Ook! Ook. Ook? Ook. Ook.
Ook. Ook. Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook!
Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.
Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook! Ook! Ook. Ook? Ook! Ook! Ook!
Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook!
Ook? Ook. Ook? Ook! Ook. Ook? Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook!
Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook.
Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook!
Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.
Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook. Ook.
Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.
Ook. Ook. Ook. Ook. Ook! Ook. Ook? Ook.

分别将其使用 Brainfuck 和 Ook! 解码之后可以得到 flag。

flag{N7F5_AD5_i5_funny!}

webshell后门

跟之前的后门查杀一样，找到 $pass = 'ba8e6c6f35a53933b871480bb9a9545c'; //angel 即得到 flag。

flag{ba8e6c6f35a53933b871480bb9a9545c}

被劫持的神秘礼物

使用 Wireshark 分析流量包，筛选 http 条目，找到唯一的 POST 请求，即可得到账号密码。

根据提示将帐号密码串起来再 MD5 一次即得到 flag。

flag{1d240aafe21a86afc11f38a45b541a49}

刷新过的图片

解压得到一张图片，根据暗示尝试 F5 隐写。java Extract .\Misc.jpg 解得一个压缩文档。分析后为伪加密，将 deFlag 处改为 00 00 即可解压出 flag。

flag{96efd0a2037d06f34199e921079778ee}

snake

010 editor 打开文件，发现其尾部有压缩文档。

binwalk -e 分离出来，解压得到两个文件。将 key 文件中的 base64 解码得到如下文本。

What is Nicki Minaj's favorite song that refers to snakes?

搜索之后可得 key 为 anaconda。根据题目暗示可知加密方式是 Serpent，使用对应解密工具解密可得 flag。

CTF{who_knew_serpent_cipher_existed}

梅花香之苦寒来

010 editor 打开文件，发现其尾部有数据。

复制出来之后用十六进制转 ASCII 可以得到一些坐标点，将其处理成 csv 格式的数据。

使用 Excel 画出散点图，可以得出一个二维码。

扫描即可得出 flag。

flag{40fc0a979f759c8892f4dc045e28b820}

菜刀666

使用 Wireshark 分析流量包，追踪 TCP 流可知道 flag 在一个压缩包内。

binwalk -e 分离出来，发现需要密码。回到 TCP 流的跟踪中可以发现一张图片的传输，将其提取出来。

得到压缩包的密码，解压即可得到 flag。

flag{3OpWdJ-JP6FzK-koCMAK-VkfWBq-75Un2z}

被偷走的文件

Wireshark 分析流量包，跟踪 TCP 流，可以发现一个压缩文档。

将其保存下来然后使用 ARCHPR 爆破得出解压密码为 5790。

解压文件即可得到 flag。

flag{6fe99a5d03fb01f833ec3caa80358fa3}

[BJDCTF2020]认真你就输了

解压后得到 xls 文件，010 editor 打开可见如下提示。

将后缀名改为 zip 打开后找到 ../charts/flag.txt，打开即可得到 flag。

flag{M9eVfi2Pcs#}

[BJDCTF2020]藏藏藏

foremost 从图片中分离出一个压缩文档，打开后可以得到一个 Word 文档，打开后可得一个二维码。

扫描二维码可得 flag。

flag{you_are_the_best!}

[GXYCTF2019]佛系青年

附加压缩文档存在伪加密，修正之后解压可得一个文本文档。在其中有如下提示。

佛曰：遮等諳勝能礙皤藐哆娑梵迦侄羅哆迦梵者梵楞蘇涅侄室實真缽朋能。奢怛俱道怯都諳怖梵尼怯一罰心缽謹缽薩苦奢夢怯帝梵遠朋陀諳陀穆諳所呐知涅侄以薩怯想夷奢醯數羅怯諸

使用与佛论禅程序解密可得 flag。

flag{w0_fo_ci_Be1}

秘密文件

与被偷走的文件一致，Wireshark 分析流量包跟踪 TCP 流，可以发现一个压缩文档。

将其保存下来然后使用 ARCHPR 爆破得出解压密码为 1903。

解压文件即可得到 flag。

flag{6fe99a5d03fb01f833ec3caa80358fa3}

[BJDCTF2020]你猜我是个啥

010 editor 打开文件，在文件尾部可发现 flag。

flag{i_am_fl@g}

[SWPU2019]神奇的二维码

binwalk 可以发现解压出来的图片中存在四个压缩文档，binwalk -e 分离出来。

除开找到的彩蛋，有用的信息在一个 Word 文档中，套娃 base64 解码之后得到 comEON_YOuAreSOSoS0great。将这串字符串作为压缩包密码解压出音频。很容易分辨出音频是摩斯电码，使用 CwGet 接收可得文本。

flag{morseisveryveryeasy}

[BJDCTF2020]一叶障目

PNG 文件 CRC32 校验失败，加之 StegSolve 无解，于是猜测图片宽高不对。使用脚本计算出宽高 ('hex:', '0x141', '0x34c') 并修正。

xaflag{66666}

穿越时空的思念

将音频文件导入 Audition，可发现右声道存在摩斯电码，使用 CwGet 接收可得文本。

去除掉重复部分并拼接可得 flag。

flag{f029bd6f551139eedeb8e45a175b0786}

[BJDCTF2020]鸡你太美

解压得到两个 gif 文件，其中有一个无法打开。使用 010 editor 打开，看到开头为 9a 两个字符，猜测是 GIF 头不完整，补全为 GIF89a 后可以成功打开并看到 flag。

flag{zhi_yin_you_are_beautiful}

[BJDCTF2020]just_a_rar

解压之后得到一个压缩文档，根据压缩文档名称提示，使用 ARCHPR 爆破得到密码 2016。

解压得到一张 jpg 图片，使用 010 editor 打开可在文件中部找到 flag。

flag{Wadf_123}

[GKCTF2020]Pokémon

下载个 VisualBoyAdvance-M 并载入游戏，根据剧情和提示走到 103 号路就能看到 flag。

flag{PokEmon_14_CutE}

[ACTF新生赛2020]outguess

解压出来非常多奇怪文件，不过根据题目名称，应该是 outguess 隐写，所以要找一下 key。在图片的属性中找到一串社会主义核心价值观，解密一下可以得到 abc，因此 abc 是 key。

将 abc 作为密钥对图片执行 outguess 解密操作即可得到 flag。

ACTF{gue33_Gu3Ss!2020}

[BJDCTF2020]纳尼

010 editor 打开解压出来的 GIF 图片，根据文本文档提示可知需要补全 GIF 文件头，于是插入 GIF8 补全文件头。用 PS 打开逐帧导出可以得到一串字符串。

得到字符串为 Q1RGe3dhbmdfYmFvX3FpYW5nX2lzX3NhZH0=，base64 解码后得到 flag。

CTF{wang_bao_qiang_is_sad}

[SWPU2019]我有一只马里奥

运行一次可执行文件，可以得到提示。

ntfs      
flag.txt

于是尝试使用 NTFS Stream Editor 分析，可以发现输出的文本文档中包含附加数据。

swupctf{ddg_is_cute}

谁赢了比赛？

010 editor 打开文件，发现其尾部有压缩文档。binwalk -e 分离出来，使用 ARCHPR 爆破得到密码 1020。

得到一张 GIF 图片，使用 PS 打开，在图层 310 处可以看见 hint do_you_know_where_is_flag。将图层导出，使用 StegSolve 解隐写，可以得到一个二维码。

扫描即可得到 flag。

flag{shanxiajingwu_won_the_game}

Mysterious

用 IDA 打开分析程序，根据字符串 well done 可以找到子程序 sub_401090。将其反编译得到以下代码。

int __stdcall sub_401090(HWND hWnd, int a2, int a3, int a4)
{
  int v4; // eax
  char Source; // [esp+50h] [ebp-310h]
  CHAR Text[4]; // [esp+154h] [ebp-20Ch]
  char v8; // [esp+159h] [ebp-207h]
  __int16 v9; // [esp+255h] [ebp-10Bh]
  char v10; // [esp+257h] [ebp-109h]
  int Value; // [esp+258h] [ebp-108h]
  CHAR String; // [esp+25Ch] [ebp-104h]
  char v13; // [esp+25Fh] [ebp-101h]
  char v14; // [esp+260h] [ebp-100h]
  char v15; // [esp+261h] [ebp-FFh]

  memset(&String, 0, 0x104u);
  Value = 0;
  if ( a2 == 16 )
  {
    DestroyWindow(hWnd);
    PostQuitMessage(0);
  }
  else if ( a2 == 273 )
  {
    if ( a3 == 1000 )
    {
      GetDlgItemTextA(hWnd, 1002, &String, 260);
      strlen(&String);
      if ( strlen(&String) > 6 )
        ExitProcess(0);
      v4 = atoi(&String);
      Value = v4 + 1;  //Value should be 122 + 1 == 123
      if ( v4 == 122 && v13 == 120 && v15 == 122 && v14 == 121 )
      {
        strcpy(Text, "flag");
        memset(&v8, 0, 0xFCu);
        v9 = 0;
        v10 = 0;
        _itoa(Value, &Source, 10);
        strcat(Text, "{");
        strcat(Text, &Source); //123
        strcat(Text, "_");
        strcat(Text, "Buff3r_0v3rf|0w");
        strcat(Text, "}");
        MessageBoxA(0, Text, "well done", 0);
      }
      SetTimer(hWnd, 1u, 0x3E8u, TimerFunc);
    }
    if ( a3 == 1001 )
      KillTimer(hWnd, 1u);
  }
  return 0;
}

由 Value = v4 + 1 和判断中的 v4 == 122 可知 Value 在满足走下去的条件时应为 123，将下文的字符串拼接起来即可得到 flag。

flag{123_Buff3r_0v3rf|0w}

sqltest

Wireshark 分析流量包筛选 http 条目可知是 SQL 盲注的流量包，flag 长度为 38。按照盲注的逻辑记录下返回值为真的 ASCII 数值。

102 108 97 103 123 52 55 101 100 98 56 51 48 48 101 100 53 102 57 98 50 56 102 99 53 52 98 48 100 48 57 101 99 100 101 102 55 125

将其转为字符串可得 flag。

flag{47edb8300ed5f9b28fc54b0d09ecdef7}

[GXYCTF2019]gakki

010 editor 打开文件，发现其尾部有压缩文档。

binwalk -e 分离出来，使用 ARCHPR 爆破得到密码 8864。

解压后得到看不懂的文本文档，统计文本字符可得 flag。

GXY{gaki_IsMyw1fe}

[BJDCTF 2nd]TARGZ-y1ng

套娃解压压缩包，压缩包的名称是下一个压缩包的解压密码。

import zipfile

def Unzip(fileName):
    while True:
        password = fileName.split('.')[0]
        zip = zipfile.ZipFile(fileName,'r')
        zip.extractall(pwd=password.encode("UTF-8"))
        fileName = zip.namelist()[0]
        zip.close()
Unzip("hW1ES89jF.tar.gz")

解压到最后即可得到 flag 文件。

BJD{wow_you_can_rea11y_dance}

[HBNIS2018]excel破解

010 editor 打开文件，可以直接找到 flag。

CTF{office_easy_cracked}

喵喵喵

使用 StegSolve 可解出一张图片。

保存下来修正图片文件头并大致修正图片高度后可得一二维码，可将其反色。

扫描二维码可以得到一个百度网盘分享链接，把文件下载下来，得到一个压缩包。看了 WriteUp 才知道这里本来有个 hint 是 NTFS，于是上 NTFS 流分析。压缩文件必须使用 WinRAR 去解压才能找到文件流，得到一个 pyc 文件，反编译如下。

#!/usr/bin/env python
# visit http://tool.lu/pyc/ for more information
import base64

def encode():
    flag = '*************'
    ciphertext = []
    for i in range(len(flag)):
        s = chr(i ^ ord(flag[i]))
        if i % 2 == 0:
            s = ord(s) + 10
        else:
            s = ord(s) - 10
        ciphertext.append(str(s))

    return ciphertext[::-1]

ciphertext = ['96','65','93','123','91','97','22','93','70','102','94','132','46','112','64','97','88','80','82','137','90','109','99','112']

写个解密函数。

def decode():
    cipherText = ciphertext[::-1]
    flag = ""
    for i in range(len(cipherText)):
        s = int(cipherText[i]) - 10 if i % 2 == 0 else int(cipherText[i]) + 10
        s = chr(s ^ i)
        flag += s
    return flag

可得到 flag。

flag{Y@e_Cl3veR_C1Ever!}

[ACTF新生赛2020]base64隐写

压缩包解压得到文本文档，使用 Base64 隐写工具可解出 flag。

ACTF{6aseb4_f33!}

[HBNIS2018]来题中等的吧

解压得到一张图片，转换为摩斯电码。

.- .-.. .--. .... .- .-.. .- -...

将摩斯电码解出即得 flag。

flag{ALPHALAB}

[SWPU2019]伟大的侦探

010 editor 下编辑为 EBCDIC 可见压缩包密码 wllm_is_the_best_team!。解压压缩包后对照小人跳舞得解密表可得flag。

flag{iloveholmesandwllm}

黑客帝国

解压文件得到一个文本文档，里面有很多数据。观察容易得出 52 61 72 对应 Rar，因此数据是个压缩文档，编写脚本将其还原。

import binascii
hexData = open('7ecb86887bd03535a7f9959e934e901e.txt').read()
file = open('7ecb86887bd03535a7f9959e934e901e.rar', 'wb')
file.write(binascii.unhexlify(hexData))
file.close()

使用 ARCHPR 爆破得到密码 3690。

解压得到一个图片文件，将文件头修正后打开图片即可得到 flag。

flag{57cd4cfd4e07505b98048ca106132125}

[WUSTCTF2020]find_me

解压所得的图片的属性中发现盲文字符 ⡇⡓⡄⡖⠂⠀⠂⠀⡋⡉⠔⠀⠔⡅⡯⡖⠔⠁⠔⡞⠔⡔⠔⡯⡽⠔⡕⠔⡕⠔⡕⠔⡕⠔⡕⡍=。使用加解密工具解密可得 flag。

wctf2020{y$0$u_f$1$n$d$_M$e$e$e$e$e}

弱口令

压缩文件备注有内容，复制到 VS Code 可知是摩斯电码。

解出摩斯电码可得 HELL0FORUM，将其作为压缩包密码解压出图片。这里需要使用 Cloacked Pixel 去解密得出 flag。

flag{jsy09-wytg5-wius8}

[MRCTF2020]你能看懂音符吗

将压缩包文件头修正后得到一个文档。根据文档提示，将文档解压后读取 document.xml 可以发现音符。

♭♯♪‖¶♬♭♭♪♭‖‖♭♭♬‖♫♪‖♩♬‖♬♬♭♭♫‖♩♫‖♬♪♭♭♭‖¶∮‖‖‖‖♩♬‖♬♪‖♩♫♭♭♭♭♭§‖♩♩♭♭♫♭♭♭‖♬♭‖¶§♭♭♯‖♫∮‖♬¶‖¶∮‖♬♫‖♫♬‖♫♫§=

将其放到对应的加解密工具里解密即可得到 flag。

MRCTF{thEse_n0tes_ArE_am@zing~}

john-in-the-middle

使用 Wireshark 分析流量包，筛选 http 条目，可以导出很多图片。使用 StegSolve 解隐写可以发现一张图片中出现了一条线。

对应另外一张图的暗示，将线条补齐获得旗帜（flag)。

于是使用 StegSolve 将这个两个图片 Combine 在一起分析，得到 flag。

flag{J0hn_th3_Sn1ff3r}

[SWPU2019]你有没有好好看网课?

解压得到很多文件，首先根据压缩包备注对 flag3.zip 使用 ARCHPR 爆破得到密码 183792。

解压得到一个视频，在 Premiere 下打开逐帧播放可以得到信息。

其中第一段是 Tap Code，使用对应的码表可解出为 wllm。

  1  2  3  4  5
1 A  B C/K D  E
2 F  G  H  I  J 
3 L  M  N  O  P
4 Q  R  S  T  U
5 V  W  X  Y  Z

第二段直接 base64 解码为 up_up_up。将其拼合可得 wllmup_up_up。将其作为解压密码解压 flag2.zip，得到一张图片。

使用 010editor 打开图片可以直接找到 flag。

swpuctf{A2e_Y0u_Ok?}

[GUET-CTF2019]KO

将得到的内容直接 Ook! 解码即可得 flag。

flag{welcome to CTF}

[HBNIS2018]caesar

打开之后得到一串文本 gmbhjtdbftbs，使用凯撒加密的工具解密可得 flag。

flag{flagiscaesar}

zip

解压之后得到了很多 zip 文件，根据提示需要提取内容，但是压缩包需要密码，文件大小为 4 字节，于是尝试 CRC 爆破。写个脚本提取内容。

import binascii
import zipfile
import string

base64StrDictionary = string.ascii_letters + string.digits + '+' + '/' + '='

def CRCZipFile(zipPath):
    return zipfile.ZipFile(zipPath).getinfo("data.txt").CRC

def CrackData(sampleCRC):
    for i in base64StrDictionary:
        for j in base64StrDictionary:
            for k in base64StrDictionary:
                for h in base64StrDictionary:
                    data = i + j + k + h
                    if sampleCRC == (binascii.crc32(data.encode())):
                        return data
def CrackZip():
    data = ""
    for i in range(68):
        fileName = "b2ca8799-13d7-45df-a707-94373bf2800c\\out{}.zip".format(i)
        data += CrackData(CRCZipFile(fileName))
        print(data)
    print(data)

CrackZip()

得到了一串 base64 字符串。

z5BzAAANAAAAAAAAAKo+egCAIwBJAAAAVAAAAAKGNKv+a2MdSR0zAwABAAAAQ01UCRUUy91BT5UkSNPoj5hFEVFBRvefHSBCfG0ruGnKnygsMyj8SBaZHxsYHY84LEZ24cXtZ01y3k1K1YJ0vpK9HwqUzb6u9z8igEr3dCCQLQAdAAAAHQAAAAJi0efVT2MdSR0wCAAgAAAAZmxhZy50eHQAsDRpZmZpeCB0aGUgZmlsZSBhbmQgZ2V0IHRoZSBmbGFnxD17AEAHAA==

将其解码后得到一个文件，根据文件尾 C4 3D 7B 00 40 07 00 可知是 Rar 文件，补全修正文件头。打开文件即可在文件备注处看到 flag。

flag{nev3r_enc0de_t00_sm4ll_fil3_w1th_zip}

[MRCTF2020]ezmisc

010 editor 打开文件发现提示 CRC Mismatch。于是打开脚本爆破图片宽高，得到 hex: 0x1f4 0x1c8，对应修正之后打开图片可得 flag。

MRCTF{1ts_vEryyyyyy_ez!}

[HBNIS2018]低个头

这波就蛮神奇的，根据给出密文 EWAZX RTY TGB IJN IO KL 用手指划键盘可得出 CTF 三个字符。

flag{CTF}

[GXYCTF2019]SXMgdGhpcyBiYXNlPw==

题目 base 解码之后得到 Is this base? 的信息。感觉在暗示 base64 隐写，拿出脚本跑一下得到 flag。

GXY{fazhazhenhaoting}

[ACTF新生赛2020]NTFS数据流

使用 NTFSStreamEditor2 扫描，得出 flag 文件。

ACTF{AAAds_nntfs_ffunn?}

[RoarCTF2019]黄金6年

010 editor 打开视频文件，在文件最后可以找到一串 base64 字符。

UmFyIRoHAQAzkrXlCgEFBgAFAQGAgADh7ek5VQIDPLAABKEAIEvsUpGAAwAIZmxhZy50eHQwAQAD
Dx43HyOdLMGWfCE9WEsBZprAJQoBSVlWkJNS9TP5du2kyJ275JzsNo29BnSZCgMC3h+UFV9p1QEf
JkBPPR6MrYwXmsMCMz67DN/k5u1NYw9ga53a83/B/t2G9FkG/IITuR+9gIvr/LEdd1ZRAwUEAA==

将其解码后保存发现是个需要密码的压缩文档。回到文档中找提示，发现了二维码。

稍带处理后扫描得出 i play ctf 的字样，拼接发现不对，但是实在找不到了，上网看了一波 WriteUp 发现还有个 want，于是成功解压，得到了 flag。

roarctf{CTF-from-RuMen-to-RuYuan}

间谍启示录

挂载磁盘到本地，发现一个 exe，根据暗示运行一次 exe，发现是自解压，同时生成了一些文件，其中的某一些被解压后脚本删除了。于是不用自解压，直接 7-zip 打开，发现有个 flag.exe。

解压出来运行之后即会生成 flag。

Flag{379:7b758:g7dfe7f19:9464f:4g9231}

我吃三明治

用 010 editor 打开解压的图片，发现在文件尾部有一串字符串，后面接着另一张图片。图片提取出来之后是一张朴实的三明治图片。字符串用 base32 解码之后即为 flag。

flag{6f1797d4080b29b64da5897780463e30}

[SUCTF2018]single dog

010 editor 打开文件可以发现很多文件，foremost 分离一下得到一个压缩包。压缩包中有一个文本文档，其中是 aaencode 的代码。

将代码复制到工具中解密可得如下内容。

function a()
{
var a="SUCTF{happy double eleven}";
alert("双十一快乐");
}
a();

SUCTF{happy double eleven}

[V&N2020 公开赛]拉胯的三条命令

找开放的端口，换种思路也就是找有响应且建立连接的端口。打开 Wiresahrk 分析流量包，筛选 tcp.flags == 0x010 || tcp.flags == 0x02 找到全部 TCP 建立连接与相应的数据包，找到二者交替出现的端口，即为开放的端口。筛选之后找出以下端口。

21
22
631
801
3306

根据提示可知 flag。

flag{21226318013306}

[安洵杯 2019]吹着贝斯扫二维码

解压得到一堆图片和一个压缩包，将二维码拼好。

扫描二维码得到信息 BASE Family Bucket ??? 85->64->85->13->16->32。将压缩包备注取出，按照如上步骤倒序操作，得到了 ThisIsSecret!233。将其作为压缩包密码解压即可得到 flag。

flag{Qr_Is_MeAn1nGfuL}

从娃娃抓起

根据提示可知，给出的密文为两种汉字编码，四位数字描绘一个汉字的大概就是标准中文电码。对应解密之后为如下内容。

剩下的英文字符描绘汉字的编码联系到各种输入法，容易猜想到是五笔输入法，将其转换后得到 也要从娃娃抓起。再根据提示将上述内容拼接后转为 MD5，得到 flag。

flag{3b4b5dccd2c008fe7e2664bd1bc19292}

小易的U盘

第 32 个副本 exe 放到 IDA 里看字符串可以直接看到 flag。

flag{29a0vkrlek3eu10ue89yug9y4r0wdu10}

[ACTF新生赛2020]swp

Wireshark 打开流量包筛选 http 条目，分离出 secret.zip，根据 hint.html 的内容得知压缩包是伪加密。

修正压缩包伪加密，解压之后用 010 editor 打开 .swp 文件，可以直接找到 flag。

actf{c5558bcf-26da-4f8b-b181-b61f3850b9e5}

百里挑一

Wireshark 打开数据包，发现很多图片流量，使用文件>导出对象将整个 HTTP 对象导出，在图片文件的备注中可以发现一半 flag。

根据文件名再去追踪对应的 TCP 流，猜测剩下的部分也存在 Exif 中。跟踪到 TCP 流 114，可以在 Exif 中找到剩下半个 flag。

flag{ae58d0408e26e8f26a3c0589d23edeec}

[WUSTCTF2020]alison_likes_jojo

010 打开 boki.jpg，发现其尾部有压缩文档。

binwalk -e 分离出来，使用 ARCHPR 爆破得到密码 888866。

解压后得到一个文本文档，内容是 WVRKc2MySkhWbmxqV0Zac1dsYzBQUT09。三重 base64 解密之后得到 killerqueen。

直接把它作为 flag 发现并不正确，于是猜测为 key，尝试对 jljy.jpg 进行 outguess，得到 flag。

wctf2020{pretty_girl_alison_likes_jojo}

[GUET-CTF2019]zips

首先使用 ARCHPR 爆破 222.zip，得到密码 723456。

解压之后得到 111.zip，修正伪加密之后解压出 flag.zip 和 start.sh，根据脚本内的内容可知 flag.zip 的密码为出题时的时间。结合 111.zip 和 flag 的修改时间确定范围，使用 ARCHPR 爆破出密码。

#!/bin/bash
#
zip -e --password=`python -c "print(__import__('time').time())"` flag.zip flag

解压 flag.zip 就可以得到 flag。

flag{fkjabPqnLawhvuikfhgzyffj}

[安洵杯 2019]Attack

Wireshark 分析数据包，从数据流中分理出包含 flag 的压缩文档。

根据压缩包文档备注，得知需要找到 administrator 的密码，于是从数据包中导出 lsass.dmp，使用 mimikatz 提取出密码。

使用提取出的密码 W3lc0meToD0g3 解压压缩包即得到 flag 文件。

D0g3{3466b11de8894198af3636c5bd1efce2}

二维码

简单得拼一下，然后用微信扫即可得 flag。

flag{7bf116c8ec2545708781fd4a0dda44e5}

[WUSTCTF2020]爬

010 editor 打开文件后确定为 pdf 文件，修正拓展名。使用 Acrobat DC 打开 pdf 文件，根据提示将图片移开，得到如下图片。

0x77637466323032307b746831735f31735f405f7064665f616e645f7930755f63616e5f7573655f70686f7430736830707d

将上述图片中的文字提取出来，利用十六进制转 ASCII 可得 flag。

wctf2020{th1s_1s_@_pdf_and_y0u_can_use_phot0sh0p}

[WUSTCTF2020]girlfriend

解压得到一段音频，听了一段之后分辨出是 DTMF。尝试使用在线解密工具解密。

得到如下内容。

999*666*88*2*777*33*6*99*4*444*777*555*333*777*444*33*66*3*7777

然后对应手机九键进行解密，可得如下内容。

YOUAREMXGIRLFRIENES

对内容进行修正并猜测，就可以得出 youaremygirlfriends。

flag{youaremygirlfriends}

[MRCTF2020]CyberPunk

运行程序之后提示检测时间，于是把系统时间更改到一致即可得到 flag。

MRCTF{We1cOm3_70_cyber_security}

USB

binwalk 发现解压出来的文件中有几个压缩文档，binwalk -e 提取出来。

得到了一个 USB 流量的流量包，使用 "D:\Program Files\Wireshark\tshark.exe" -r key.pcapng -T fields -e usb.capdata > usbdata.txt 分离出 USB 的 Leftover Capture Data，使用 UsbKeyboardDataHacker 来进行分析，得到如下字符串。

aababacbbdbdccccdcdcdbbcccbcbbcbbaababaaaaaaaaaaaaaaaaaakey{xinan}

由 RAR 文件结构可知其 HeadType 应为 0x74，将其修正之后解压压缩文档，得到一张图片。

StegSolve 可解出一张二维码，扫描可得如下内容。

ci{v3erf_0tygidv2_fc0}

以 xinan 为密码，使用 Vigenère Decode 对上述内容操作，再用以 2 为密钥的栅栏密码解密即可得到 flag。

flag{vig3ne2e_is_c00l}

[SWPU2019]Network

TTL 的题目，把网上的脚本稍微改一点，可以提取出一个压缩文档。

import binascii

with open('ttl.txt') as f:
    lines = f.readlines()
n_num = []

for i in lines:
    if i != '\n':
        n_num.append(int(i))

rlt = ''
for i in range(0, len(lines)):
    tmp = bin(n_num[i])[2:]
    tmp = '0' * (8 - len(tmp)) + tmp
    rlt += tmp[0:2]

rlt2 = ''
for i in range(0, len(rlt), 8):
    rlt2 += chr(int(rlt[i:i + 8], 2))
with open('fi.txt', 'w') as f:
    f.write(rlt2.rstrip())

hexData = open('fi.txt').read()
file = open('fi.zip', 'wb')
file.write(binascii.unhexlify(hexData))
file.close()

修正所得压缩包的伪加密，得到一个文本文档。对其循环 base64 解码即可得到 flag。

flag{189ff9e5b743ae95f940a6ccc6dbd9ab}

[SUCTF2018]followme

Wireshark 分析流量包，跟到一个 POST 请求处可以看到 flag。

SUCTF{password_is_not_weak}

[RCTF2019]draw

很像 PC Logo 的代码，初中的时候玩过一些。可惜的是 PC Logo 不兼容 x64 的系统了，只能找了个在线的解释器。将代码粘贴进去执行可以得到一幅图，同时也是 flag。

flag{RCTF_HeyLogo}

[XMAN2018排位赛]通行证

先对附件给出的字符串解 base64，再以 7 为 key 做 Rail Fence Cipher Encode，再 ROT13 一次，就可以得到 flag。

xman{oyay_now_you_get_it}

[安洵杯 2019]easy misc

解压出的文件中，decode.zip 中包含有备注 FLAG IN ((√2524921X85÷5+2)÷15-1794)+NNULLULL,，(√2524921X85÷5+2)÷15-1794) 可算得结果为 7。使用 ARCHPR 爆破出压缩包密码为 2019456NNULLULL,。

得到字母对应字符串的替换，推测需要做词频分析。看了看网上的 WriteUp，发现我的盲水印分析不出来，可能是工具有问题，先记下答案往下走，对 11.txt 做词频分析。根据 read目录下的提示，取出词频前 16 的词，可以得到如下结果。

频数第1: (' ', 75435)
频数第2: ('e', 39628)
频数第3: ('t', 27993)
频数第4: ('a', 25887)
频数第5: ('o', 25809)
频数第6: ('n', 21337)
频数第7: ('r', 20990)
频数第8: ('h', 19535)
频数第9: ('i', 19422)
频数第10: ('s', 18870)
频数第11: ('d', 15932)
频数第12: ('l', 14385)
频数第13: ('u', 9562)
频数第14: ('y', 8293)
频数第15: ('g', 8127)
频数第16: ('w', 7744)

看了看别人的 WriteUp，词频算出来差不多但是内容却差了蛮多的，有点迷。

- QW8obWdIWT9pMkF-sd5REtRQSQWjVfXiE/WSFTajBtcw= //我拼接的字符串
+ QW8obWdIWT9pMkFSQWtRQjVfXiE/WSFTajBtcw== //官方 WriteUp 的字符串

将拼接出来的字符串 base64 解码一次再 base85 解码一次可以得到 flag。

flag{have_a_good_day1}

[MRCTF2020]Unravel!!

在解压出的音频尾部可以找到一串 AES 密文。

U2FsdGVkX1/nSQN+hoHL8OwV9iJB/mSdKk5dmusulz4=

binwalk 可知 JM.png 中包含多个图片，binwalk -e 分离可以得到一个图片。

将其作为 AES 的 key 可以解出明文 CCGandGulu。将解出的明文作为压缩包密码解压 win-win.zip 可以得到一个音频文件。SilentEye 可解出 flag。

MRCTF{Th1s_is_the_3nd1n9}

[GKCTF2020]code obfuscation

将图片修复好，扫描后得到信息 base(gkctf)。

binwalk 可知图片中包含一个压缩文件，binwalk -e 分离。根据上一步的信息，尝试后可知压缩包密码为 base58(gkctf)，即 CfjxaPF。

[UTCTF2020]docx

将 docx 文件解压后在 media 文件夹内可找到 flag 图片。

utflag{unz1p_3v3ryth1ng}

[GKCTF2020]Harley Quinn

附件压缩包的备注里有需要用到的工具提示。下载 FreeFileCamouflage，发现是图片提取软件。图片的属性中有 #password# 字样，听到最后发现有 DTMF，上传到工具识别。

得到 btdipdun，因为提示说可读短句，稍作修正后可得到 ctfisfun。将其作为密码提取图片中的隐写即可得到 flag 文件。

flag{Pudd1n!!_y0u_F1nd_m3!}

派大星的烦恼

根据题目描述，在图片中找到区块并复制出来得到字符串。

"DD"DD""""D"DD""""""DD"""DD"DD""D""DDD""D"D"DD""""""DD""D""""DD"D"D"DD""""D"DD""D"""DD"""""DDD""""D"DD"""D"""DD"""D""DD"D"D"DD"""DD""DD"D"D""DD""DD"DD"""D"""DD""DD"DD""D"D""DD"D"D"DD"""D"""DD"""D"DD""DD"""DD"D"D""DD"""D"DD""DD""DD"""""DDD""DD""DD"""D""DD""

将其转换为二进制字符串，得到了如下内容。

0110110000101100000011000110110010011100101011000000110010000110101011000010110010001100000111000010110001000110001001101010110001100110101001100110110001000110011011001010011010101100010001100010110011000110101001100010110011001100000111001100110001001100

接下来要做的就是想办法把它转换为字符串，经过尝试得出 reverse->From Binary->reverse 的路径，得出正确的 flag。

flag{6406950a54184bd5fe6b6e5b4ce43832}

[MRCTF2020]Hello_ misc

010 editor 打开解压出的图片，发现文件尾部有个压缩包，提取出来之后发现压缩包需要密码。将图用 StegSolve 可解得另一张图片。

将其保存下来，打开查看发现压缩包密码信息。

将压缩包解压之后得到了很多数字，看形式像 TTL 信息隐写。用脚本跑出信息 rar-passwd:0ac1fe6b77be5dbe。依此解开 rar 压缩文档之后得到一个 Word 文档。修正其拓展名后打开，得到一串 base64。

MTEwMTEwMTExMTExMTEwMDExMTEwMTExMTExMTExMTExMTExMTExMTExMTExMTExMTAxMTEwMDAwMDAxMTExMTExMTExMDAxMTAx
MTEwMTEwMTEwMDAxMTAxMDExMTEwMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTAxMTExMTExMTExMTExMTEwMTEwMDEx
MTEwMDAwMTAxMTEwMTExMDExMTEwMTExMTExMTAwMDExMTExMTExMTExMDAxMDAxMTAxMTEwMDAwMDExMTExMDAwMDExMTExMTEx
MTEwMTEwMTAwMDAxMTExMDExMTEwMTExMTExMDExMTAxMTExMTExMTEwMTEwMTEwMTAxMTExMTExMTAwMTEwMTExMTExMTExMTEx
MTEwMTEwMTAxMTExMTExMDExMTEwMTExMTAxMDExMTAxMTExMTExMTEwMTEwMTEwMTAxMTAxMTExMTAwMTEwMTExMTExMTExMTEx
MTEwMTEwMTAwMDAxMTAwMDAwMTEwMDAwMDAxMTAwMDExMTAwMDAwMTEwMTEwMTEwMTAxMTEwMDAwMDAxMTExMDAwMDExMTExMTEx

对其逐行解密后得到如下内容。

110110111111110011110111111111111111111111111111101110000001111111111001101
110110110001101011110111111111111111111111111111111101111111111111110110011
110000101110111011110111111100011111111111001001101110000011111000011111111
110110100001111011110111111011101111111110110110101111111100110111111111111
110110101111111011110111101011101111111110110110101101111100110111111111111
110110100001100000110000001100011100000110110110101110000001111000011111111

替换字符可以更直观得看到 flag。

  0  0        00    0                            0   000000          00  0 
  0  0  000  0 0    0                               0               0  00  
  0000 0   0   0    0       000           00 00  0   00000     0000        
  0  0 0000    0    0      0   0         0  0  0 0        00  0            
  0  0 0       0    0    0 0   0         0  0  0 0  0     00  0            
  0  0 0000  00000  000000  000   00000  0  0  0 0   000000    0000

flag{He1Lo_mi5c~}

[BSidesSF2019]zippy

Wireshark 分析流量包，追踪 TCP 流量，可以直接看到压缩文档和压缩文档的密码，提取出来解压文档即可得到 flag 文件。

CTF{this_flag_is_your_flag}

粽子的来历

将解压所得的 Word 文档文件修复，打开可得诗句。根据不同的行距将其转化为二进制标记得到如下数据。

10010100010
101010010011
100100100001
111100100001

分别将其用 MD5 摘要之后得到如下内容。

447b98f8c092f12a4773ca9809ef6b5f
59f3bfe7c1e00ba34e4558cf295544bc
d473ee3def34bd022f8e5233036b3345
d579f5f8d6c01ec08971fbc0c68f1ddd

其中第三个为 flag。

flag{d473ee3def34bd022f8e5233036b3345}

[UTCTF2020]file header

修复附件的 PNG 文件头 89 50 4E 47，查看图片可得 flag。

utflag{3lit3_h4ck3r}

[WUSTCTF2020]spaceclub

打开文件后全选可见长短错落的空格。

将短行转换为 0，长行转换为 1，得到如下字符。

011101110110001101110100011001100011001000110000001100100011000001111011011010000011001101110010011001010101111100110001011100110101111101111001001100000111010101110010010111110110011001101100010000000110011101011111011100110011000101111000010111110111001100110001011110000101111101110011001100010111100001111101

将其转换为十六进制可得 flag。

wctf2020{h3re_1s_y0ur_fl@g_s1x_s1x_s1x}

[ACTF新生赛2020]music

010 editor 打开文件看到文件头为 A1 A1 A1 但是 m4a 的文件头应该为 00 00 00，于是猜测其对文件进行了异或运算。将文件导入 CyberChef 中进行异或得到原文件。打开文件即可听出 flag。

actf{abcdfghijk}

[UTCTF2020]basic-forensics

修正文件拓展名，搜索 flag 即可。

utflag{fil3_ext3nsi0ns_4r3nt_r34l}

[SCTF2019]电单车

这题是真的少信息了，原本应该有个题目描述的。要找的是信号的地址位的 20bit。使用 Audition 转写即可得到 flag。

flag{01110100101010100110}

hashcat

010 editor 打开文件后补全拓展名。使用 AOPR 进行密码爆破得到密码为 9919。

尝试后修正拓展名为 ppt，使用 PowerPoint 打开文件后在倒数第二页可找到 flag。

Flag{okYOUWIN}

真的很杂

binwalk -e 分离出一个 apk 文件，使用 apktool 反编译文件。

查看 MainActivity.smali 可以看到如下内容。

.line 32
    .local v6, "text":Landroid/widget/TextView;
    const-string v0, "flag{25f991b27f"

    .line 33
    .local v0, "True1":Ljava/lang/String;
    const-string v1, "c"

    .line 34
    .local v1, "True2":Ljava/lang/String;
    const-string v2, "dc2f7a82a2b34"

    .line 35
    .local v2, "True3":Ljava/lang/String;
    const-string v3, "3"

    .line 36
    .local v3, "True4":Ljava/lang/String;
    const-string v4, "86e81c4}"

拼接起来即得到 flag。

flag{25f991b27fcdc2f7a82a2b34386e81c4}

[湖南省赛2019]Findme

解压得到五个图片，分别从五个图片中得到 flag 的一部分。

在第二幅图的文件尾部有一个压缩文档，文件头以 7z 开头，可是之后却是 03 04 于是猜测其实是个 zip 文档。将 7z 都替换为 PK 以修正文档。修正之后解压文档得到一堆文本文档，推测有用的信息大小不一样，于是将其按大小排序，找到 618.txt。其中包含信息如下。

You find it: 1RVcmVfc

第五幅图的尾部有如下信息。

I give U a gift:Yzcllfc0lN

第四幅图的尾部有如下信息。

another part:cExlX1BsY

第三幅图用 010 editor 打开的时候运行模板会因为 CRC 不匹配报错，而这些 CRC 值都只有最后两位，将其提取出来转 ASCII 的带如下信息。

33 52 6C 5A 33 30 3D --> 3RlZ30=

第一幅图打开时发现了 IDAT 缺失的情况，将其补齐修正。

再使用脚本爆破图片宽高，得到 ('hex:', '0xe3', '0x1c5')。将图片宽高修正。再使用 StegSolve 可解出一个二维码。

修正定位码之后扫描可得如下内容。

ZmxhZ3s0X3

将内容片段拼接，base64 解码即可得到 flag。

ZmxhZ3s0X3Yzcllfc0lNcExlX1BsY1RVcmVfc3RlZ30=

flag{4_v3rY_sIMpLe_PlcTUre_steg}

voip

Wireshark 使用 RTP 分析 VoiP 流量包，直接可以听到电话的音频，不过有些难听懂。

seccon{9001IVR}

[UTCTF2020]zero

打开之后是一段示例文字，但是文件的编码有点不一样。

根据题目暗示，找到零宽字符隐写，解得 flag。

utflag{whyNOT@sc11_4927aajbqk14}

[QCTF2018]X-man-A face

解压得到一张图片，上面有一个残缺的二维码，将其定位码修正。

扫描二维码之后得到一串字符串，将其 base32 解码即可得到 flag。

KFBVIRT3KBZGK5DUPFPVG2LTORSXEX2XNBXV6QTVPFZV6TLFL5GG6YTTORSXE7I=

QCTF{Pretty_Sister_Who_Buys_Me_Lobster}

Business Planning Group

使用 010 editor 打开图片可以发现文件尾存在 bpg 图像，将其分离出来。使用在线的工具可以将其显示并下载为 png 文件。

将图片上的文本提取出来并 base64 解码即可得到 flag。

bsides_delhi{BPG_i5_b3tt3r_7h4n_JPG}

[MRCTF2020]pyFlag

压缩包解压后为三张图片，使用 010 editor 打开图片发现每张图片的最后都有一部分信息，将其拼起来之后得到一个压缩文档。使用 ARCHPR 爆破出压缩包密码为 1234。

解压文件后得到加密的 flag。

G&eOhGcq(ZG(t2*H8M3dG&wXiGcq(ZG&wXyG(j~tG&eOdGcq+aG(t5oG(j~qG&eIeGcq+aG)6Q<G(j~rG&eOdH9<5qG&eLvG(j~sG&nRdH9<8rG%++qG%__eG&eIeGc+|cG(t5oG(j~sG&eOlH9<8rH8C_qH9<8oG&eOhGc+_bG&eLvH9<8sG&eLgGcz?cG&3|sH8M3cG&eOtG%_?aG(t5oG(j~tG&wXxGcq+aH8V6sH9<8rG&eOhH9<5qG(<E-H8M3eG&wXiGcq(ZG)6Q<G(j~tG&eOtG%+<aG&wagG%__cG&eIeGcq+aG&M9uH8V6cG&eOlH9<8rG(<HrG(j~qG&eLcH9<8sG&wUwGek2)

将其经过 base85-->From Hex-->base32-->From Hex-->base64 的解码之后即可得到 flag。

MRCTF{Y0u_Are_4_p3rFect_dec0der}

[ACTF新生赛2020]剑龙

解压得到很多文件，pwd 里有一段 aaencode 的 js 代码，解码后得到 welcom3!。将其作为密钥用 Steghide 从图片中解出一段 DES 密文。

U2FsdGVkX1/7KeHVl5984OsGUVSanPfPednHpK9lKvp0kdrxO4Tj/Q==

结合图片备注中的密钥 @#$%^&%%$) 可以解出如下内容。

think about stegosaurus

使用 Stegosaurus 工具对 O_O 文件提取数据就能得到 flag。可能是文件有问题，这部分没有复现到。

flag{3teg0Sauru3_!1}

[GUET-CTF2019]soul sipse

对音频 Steghide 解隐写解出一个文本，微云下载后的得到一张图片。

修复图片的文件头，并将图片上的内容转为文本，得到如下内容。

\u0034\u0030\u0037\u0030\u000d\u000a\u0031\u0032\u0033\u0034\u000d\u000a

Unescape Unicode Characters 解码得到如下内容。

4070
1234

将这两行相加得到 flag。

flag{5304}

[UTCTF2020]spectogram

音频文件使用 Audition 打开，在频谱部分可以看到 flag。

uctflag{sp3tr0gr4m0ph0n3}

[UTCTF2020]File Carving

010 editor 打开文件可以发现文件尾部有压缩包，分离出来解压得到一个 ELF。IDA Pro 打开反编译主程序可看到 flag。

utflag{2fbe9adc2ad89c71da48cabe90a121c0}

[RCTF2019]disk

用 010 editor 打开后可以找到 flag 的前半部分。

到这里之后本题又少信息了，原题给了 VeraCrypt 的密码 rctf。这里先用 7z 将 vmdk 解压得到一个 fat 文件。再使用 VeraCrypt 加载。挂载磁盘之后可以得到如下信息。

Password 2: RCTF2019

使用新的密码挂载 VeraCrypt 的隐藏分区。挂载之后使用 WinHex 载入磁盘可以看到后一半 flag。

rctf{unseCure_quick_form4t_vo1umer_and_corrupted_1nner_v0lume}

[HDCTF2019]你能发现什么蛛丝马迹吗

使用 Volatility2 进行镜像分析。首先 imageinfo 确定一下 profile。发现是 Win2003SP0x86, Win2003SP1x86, Win2003SP2x86，随便选一个开始 filescan | grep 桌面 看一下桌面的文件，发现一个 flag.png。将其提取出来，扫描发现是一段加密文本，接着回去找密钥。

首先 pslist 一下，发现没有 notepad 等可能读取文本文档的进程，只有 DumpIt.exe 比较可疑。考虑到在桌面发现的图片，将资源管理器的进程一起 dump 下来。使用 binwalk 分析可以发现资源管理器的 dumpfile 里面有好几个图片。

使用 foremost 将其分离出来，成功发现包含密钥的图片。

使用 AES 将密文解密即得到 flag。

flag{F0uNd_s0m3th1ng_1n_M3mory}

[watevrCTF 2019]Evil Cuteness

010 editor 打开图片可在文件尾部发现压缩文档，分离出来解压即可得到 flag 文件。

watevr{7h475_4c7u4lly_r34lly_cu73_7h0u6h}

[BSidesSF2019]table-tennis

Wireshark 打开流量包，跟到 ICMP 流量可以发现 Data 里面有 HTML 文档的数据。

筛选 frame.coloring_rule.string == "icmp || icmpv6" 可以看到流量包中的 ICMP 流量，读末尾的数据可以发现关键数据是一段 base64，将其取出后 base64 解码即可得到 flag。

CTF{JustAS0ngAb0utP1ngP0ng}

[INSHack2017]sanity

Markdown 文档，打开即可看到 flag。

INSA{Youre_sane_Good_for_you}

[INSHack2019]INSAnity

Markdown 文档，打开即可看到 flag。

INSA{YouRe_Crazy_and_I_Love_it}

[UTCTF2020]sstv

RX-SSTV 接收可得如下图片。

utflag{6bdfeac1e2baa12d6ac5384cdfd166b0}

[INSHack2019]Sanity

Markdown 文档，打开即可看到 flag。

INSA{Welcome}

[INSHack2017]insanity-

Markdown 文档，打开即可看到 flag。

INSA{Youre_crazy_I_like_it}

[GUET-CTF2019]520的暗示

解压得到一个二进制文件，将其与 0x33 做异或运算可以得到一个 jpg 图像。

查询基站的定位即可得到 flag。

flag{桂林电子科技大学花江校区}

[CFI-CTF 2018]webLogon capture

Wireshark 分析数据包，看请求可得一串字符串，URL Decode 之后可以得到 flag。

CFI{1ns3cur3_l0g0n}

key不在这里

将解压得到的图片用PhotoShop 反色之后识别二维码，得到如下内容。

https://cn.bing.com/search?q=key%E4%B8%8D%E5%9C%A8%E8%BF%99%E9%87%8C&m=10210897103375566531005253102975053545155505050521025256555254995410298561015151985150375568&qs=n&form=QBRE&sp=-1&sc=0-38&sk=&cvid=2CE15329C18147CBA4C1CA97C8E1BB8C

将其中的 m 取出来并整理分组，经过 From Decimal --> URL Decode 的路径解码后可得 flag。

flag{5d45fa256372224f48746c6fb8e33b32}

很好的色彩呃？

解压得到一张图片，取色器看每部分黄绿色的颜色可知只有最后两位有差别，因此将其取出来。

61 61 70 6a 65 73

将其从十六进制转十进制即得 flag。

flag{aapjes}

[MRCTF2020]摇滚DJ（建议大声播放

附件是一段音频，RX-SSTV 接收可以得到 flag。

merak{r3ce1ved_4n_img}

[INSHack2018]Self Congratulation

附件是一张图片，左上角有黑白相间的方块。

将其转译为二进制数据得到如下内容。

001100010011001000110011001101000011010100110110001101110011100000

去除掉最后两位 00，可以转成 ASCII 字符 12345678。

flag{12345678}

[INSHack2018]INSanity

Markdown 文档，打开即可看到 flag。

INSA{let_the_game_begin!}

[ACTF新生赛2020]frequency

解压得到一个 word 文档，打开发现隐藏文字，同时其备注还有一串字符串。将其二者拼在一起，然后 base64 解码。将解码后的字符串进行字频统计。

('1: ', ('a', 198))
('2: ', ('c', 194))
('3: ', ('t', 188))
('4: ', ('f', 180))
('5: ', ('p', 174))
('6: ', ('l', 170))
('7: ', ('o', 164))
('8: ', ('k', 159))
('9: ', ('m', 152))
('10: ', ('i', 145))
('11: ', ('j', 139))
('12: ', ('n', 133))
('13: ', ('u', 128))
('14: ', ('h', 116))
('15: ', ('b', 109))
('16: ', ('y', 106))
('17: ', ('g', 100))
('18: ', ('v', 92))
('19: ', ('r', 87))
('20: ', ('d', 79))
('21: ', ('x', 73))
('22: ', ('e', 68))
('23: ', ('s', 61))
('24: ', ('z', 54))
('25: ', ('w', 48))
('26: ', ('q', 41))

actf{plokmijnuhbygvrdxeszwq}

greatescape

Wireshark 分析流量包，TCP 流量跟踪到流 19 可以发现 RSA 私钥，将其保存下来。

将密钥导入 Wireshark，跟踪 TLS 流到 80 可以在请求中看到 flag。

INS{OkThatWasWay2Easy}

[INSHack2019]gflag

G Code 文件，上传到在线预览的网站可以看到包含 flag 的渲染。

INSA{3d_pr1nt3d_fl49}

[GKCTF2020]Sail a boat down the river

视频中可见一个二维码，扫描后可得到一个百度网盘链接。

https://pan.baidu.com/s/1tygt0Nm_G5fTfVFlgxVcrQ

根据视频中刷卡器的闪烁可以得出摩斯电码。

-.-- .-- ---.. --.
yw8g

下载得到数独文件，将数独解出可得到密钥。

52693795149137

将明文作为压缩包的解压密码将其解压。使用 OverTure 打开解压出来的谱面，可找到 flag。

flag{gkctf_is_fun}

[MRCTF2020]小O的考研复试

简单 JavaScript 算一下可以得到 flag。

flag{577302567}

[QCTF2018]X-man-Keyword

Cloacked Pixel 可以解出隐藏的文字。

PVSF{vVckHejqBOVX9C1c13GFfkHJrjIQeMwf}

使用 Nihilist 对应的解码可以得到 flag。

QCTF{cCgeLdnrIBCX9G1g13KFfeLNsnMRdOwf}

[MRCTF2020]寻找xxx

解压得到一段 DTMF 音频，上传到在线工具得到如下内容。

一开始以为这就是 flag，结果是要把数字发给公众号。

MRCTF{Oh!!!!!_Y0u_f1nd_my_secret}

Beautiful_Side

解压所得的图片末尾还有一张 PNG 图像，提取出来之后是半个二维码。先将其定位码补全。

将其上传到 QRazyBox 尝试修复二维码。在纠错等级为高，遮掩层模式为 2 的时候发现可以成功提取出 flag。

Flag{OQWIC_4DS1A_S034S}

[XMAN2018排位赛]AutoKey

Wireshark 打开发现是 USB 流量包，稍微跟一下发现跟鼠键的很像，于是用脚本提取出来。

[+] Found : <CAP>a<CAP>utokey('****').decipheer('<CAP>mplrvffczeyoujfjkybxgzvdgqaurkxzolkolvtufblrnjesqitwahxnsijxpnmplshcjbtyhzealogviaaissplfhlfswfehjncrwhtinsmambvexo<DEL>pze<DEL>iz')

整理后得到如下密文。

Mplrvffczeyoujfjkybxgzvdgqaurkxzolkolvtufblrnjesqitwahxnsijxpnmplshcjbtyhzealogviaaissplfhlfswfehjncrwhtinsmambvexpziz

使用在线网站提供的爆破脚本，可以解出如下内容。

-674.914569565 autokey, klen 8 :"FLAGHERE", HELLOBOYSANDGIRLSYOUARESOSMARTTHATYOUCANFINDTHEFLAGTHATIHIDEINTHEKEYBOARDPACKAGEFLAGISJHAWLZKEWXHNCDHSLWBAQJTUQZDXZQPF

flag{JHAWLZKEWXHNCDHSLWBAQJTUQZDXZQPF}

[DDCTF2018]第四扩展FS

010 editor 打开图片发现文件末尾有未知区块。提取出来仔细甄别可以知道有一个压缩文档。

将压缩文档提取出来，发现需要密码。在 FS.jpg 的备注中发现了字符串 Pactera，将其作为密码可以成功解压文档。根据文档内容可猜测需要做频次分析，于是做频次分析得到如下结果。

- DDCTF{huanwe1sik4o!} //我这次得到的 flag
+ DDCTF{x1n9shaNgbIci} //网上某 WriteUp 的 flag (我也不知道为什么交这个是对的)

[INSHack2017]hiding-in-plain-sight

binwalk 可以发现解压出来的图片里有多张图片，于是 foremost 将其分离出来。

得到一张包含 flag 的图片。

INSA{l337_h4xx0r5_c0mmun1c473_w17h_PNGs}

[CFI-CTF 2018]CFI-in-Kotlin

skylot/jadx: https://github.com/skylot/jadx

jadx 简单反编译附件给出的 APK，在 com/sagold/cfievent/LoginActivity.java 下可以找到如下代码。

private static final String[] DUMMY_CREDENTIALS = {"alerionMascot@CFIUL.com:HappyFirstYear"};

很容易发现这个 APP 实现了登录并且登录上去就会显示 flag。既然账号密码都已经拿到了，不妨安装一下并登录。然而登录上去了也没 flag。但是代码的实现逻辑确实是这样的。

@Override // android.support.v7.app.AppCompatActivity, android.support.v4.app.SupportActivity, android.support.v4.app.FragmentActivity
    public void onCreate(@Nullable Bundle bundle) {
        super.onCreate(bundle);
        setContentView(R.layout.activity_information);
        if (getIntent().getBooleanExtra(IS_ADMIN, false)) {
            showLoginFlag();
        }
    }

因此我去查了 WriteUp，其中描述如下。

With a internet connection, the flag will appear under the CFI logo.

Fine，那么这题的 flag 可能出了点问题。

CFI{DOUMMY_creeeeeddddd_issSoFriENDlieee_QUACKKKK}

[watevrCTF 2019]Polly

附件给出的是一个方程，推测其 x 为不同取值时可以求得 flag。因此写出如下代码。

def CalculateX(x):
    return # 这里写方程，太长了就不贴了

for i in range(100):
    print(chr(CalculateX(i)))

需要注意的是，因为方程数字太大了，需要使用 sagemath 才能算出准确结果。算出前 100 位可知其中含有 flag。

watevr{polly_polynomials_youtube.com/watch?v=THNWVVn9JO0}

[BSidesSF2019]thekey

简单的键盘流量分析， Leftover Capture Data 提取出来再使用 USB Keyboard Data Hacker 跑一下可得如下内容。

[+] Found : viim<SPACE>flaag.ttxt<RET>iTthe<SPACE>flaag<SPACE>is<SPACE>ctf<ESC>vbUuA{[my_favoritte_editor_is_vim}<ESC>hhhhhhhhhhhhhhhhhhhau<ESC>vi{U<ESC>";wq<RET>

ctf{MY_FAVOURITE_EDITOR_IS_VIM}

[watevrCTF 2019]Unspaellablle

附件给出了一份脚本，稍微找一下可以发现其原本的脚本。

https://imsdb.com/transcripts/Stargate-SG1-Children-Of-The-Gods.html

将两份脚本使用 CyberChef 进行比较即可得到 flag。

watevr{icantspeel_tiny.cc/2qtdez}

[INSHack2017]remote-multimedia-controller

附件解压之后得到一个流量包，使用 Wireshark 跟踪到 TCP 流 2 可得一串 base64 字符串。

Vmxkd1NrNVhVbk5qUlZKU1ltdGFjRlJYZEhOaWJFNVhWR3RPV0dKVmJEWldiR1JyV1ZkS1ZXRXphRnBpVkVaVFYycEtVMU5IUmtobFJYQlRUVmhDTmxZeFdtdGhhelZ5WWtWYWFWSlViRmRVVlZaYVRURmFjbFpyT1ZaV2JXUTJWa1pvYTFkck1YVlVhbHBoVWxack1GUlZaRXRqVmxaMVZHMTRXRkpVUlRCWFdIQkdUbGRHY2s1VmFFOVdNWEJoV1Zkek1XSldaSFJPVm1SclZsZDRXbFJWVm5wUVVUMDk=

使用 CyberChef 套娃解码后可得如下内容。

Good job ! You found the flag: INSA{TCP_s0ck3t_4n4lys1s_c4n_b3_fun!}

INSA{TCP_s0ck3t_4n4lys1s_c4n_b3_fun!}

[GWCTF2019]math

附件给出的是一个 ELF 文件，使用 IDA 查看可以发现如下逻辑。

puts("Pass 150 levels and i will give you the flag~");
puts("====================================================");
printf("Now level %d\n", (unsigned int)v9);
printf("Math problem: %d * %d - %d + %d = ??? ", v4, v5, v6, v7);
puts("Give me your answer:");
read(0, &buf, 0x80uLL);
if ( (unsigned int)strtol(&buf, 0LL, 0xA) != v5 * v4 - v6 + v7 )
{
  puts("Try again?");
  exit(0);
}
puts("Right! Continue~");
++v9;
sleep((unsigned __int64)"Right! Continue~");
}
while ( v9 <= 0x95 );
  if ( v9 != 0x96 )
  {
    puts("Wrong!");
    exit(0);
  }
puts("Congratulation!");
system("/bin/sh");
return 0;

因此需要连续计算正确 150 次计算题，而且需要与远程交互。因此用 pwntools 来写脚本实现。

from pwn import *
process = remote('node3.buuoj.cn', 26631)
for i in range(150):
    process.recvuntil('Math problem: ')
    expression = process.recvuntil('=').decode().replace('=', '')
    expression = expression.replace(' ', '')
    expression = expression.translate(str.maketrans("+-*/", "    "))
    expression = expression.split(' ')
    print(str(expression))
    process.sendline(str(int(expression[0]) * int(expression[1]) - int(expression[2]) + int(expression[3])))
process.interactive()

flag{0e6a2af0-83e3-4fce-8535-a5bfd4c4cca9}

[INSHack2018]Spreadshit

附件中给出了一个 ods 文件，将其使用 Excel 打开，查找并选中全部空格可得 flag。

INSA{3cf6463910edffb0}

[DDCTF2018](╯°□°）╯︵ ┻━┻

题目给出的附件有如下内容。

d4e8e1f4a0f7e1f3a0e6e1f3f4a1a0d4e8e5a0e6ece1e7a0e9f3baa0c4c4c3d4c6fbb9b2b2e1e2b9b9b7b4e1b4b7e3e4b3b2b2e3e6b4b3e2b5b0b6b1b0e6e1e5e1b5fd

尝试用 CyberChef 的 From Hex 解码，得到了不可读的字符串，考虑到字符串本身可能经过了运算。猜测最后一个字符 0xfd 应该与 flag 的结尾也就是 } 字符相对应，也就是原本应该是 0x7d。因此尝试将此前得到的结果减去 0x80，得到了如下内容。

recipe=From_Hex('None')SUB(%7B'option':'Hex','string':'0x80'%7D)

That was fast! The flag is: DDCTF{922ab9974a47cd322cf43b50610faea5}

DDCTF{922ab9974a47cd322cf43b50610faea5}

[SUCTF 2019]Game

可以在附件给出的代码中的 index.html 中找到如下内容。

<?php echo "here is your flag:ON2WG5DGPNUECSDBNBQV6RTBNMZV6RRRMFTX2===" ?>

使用 Base32 解码字符串后得到了假 flag suctf{hAHaha_Fak3_F1ag}，于是将分析转向图片。使用 StegSolve 可解得图片中包含的隐写内容。

将其提取出来可以得到如下内容，推测其是 AES 加密之后的密文。

U2FsdGVkX1+zHjSBeYPtWQVSwXzcVFZLu6Qm0To/KeuHg8vKAxFrVQ==

使用之前得到的假 flag 作为 key 对密文进行 Triple DES 解密可得真正的 flag。

suctf{U_F0und_1t}

[GUET-CTF2019]虚假的压缩包

解压附件得到真实的压缩包和虚假的压缩包。虚假的压缩包是伪加密，将其 deFlags 修改成 0 即可解压其中的文件，得到如下内容。

数学题
n = 33
e = 3
解26

-------------------------
答案是

很容易看出这是简单的 RSA。将 $n$ 分解为 $11 \times 3$ 可得其欧拉值为 $\rho{(n)} = (11 - 1) \times (3 - 1) = 20$，$d \times e \mod 20 \equiv 1$，算得 $d = 7.$ pow(c,d,n) = pow(26,7,33) = 5。因此得到了 答案是5。将其作为压缩包密码解压真实的压缩包。

解压得到了一张图片和一段文本。使用 010 editor 打开图片并运行 PNG 模板可以发现爆出了熟悉的 CRC Mismatch。尝试使用图片宽高爆破脚本修正宽高为 ('hex:', '0xc6', '0xf2')，得到了如下图片。

此时可知需要将得到的文本亦或 5，写个脚本来实现。

text = open("亦真亦假", 'r').read()
result = open("result.txt", 'w')
[result.write(hex(int(i, 16) ^ 5)[2:]) for i in text]

使用脚本将文件中的内容处理过后再将得到的内容 From Hex 解码一次可以得到一个 Word 文档。将其打开后可以在文章末尾发现超出文本的红色波浪线。因此尝试将超出的部分的字体颜色调深，此时可以得到 flag。

FLAG{_th2_7ru8_2iP_}

蜘蛛侠呀

将你获得的明显信息md5加密之后以flag{xxx}的格式提交。

Wireshark 分析附件给出的流量包，跟踪 TCP 流 1 可以发现一个 GET /no_flag.zip 响应为 304 的请求。再分析 ICMP 协议的流量，可以发现其中包含着数据。使用 tshark tshark -r .\out.pcap -T fields -e data > data.txt 将其中的数据提取出来。将提取得到的数据简单处理后用 CyberChef 通过 Unique --> From Hex 后可以得到一个以 $$START$$-----BEGIN CERTIFICATE----- 开头的文件。将 $$START$$ 去除掉之后再将证书格式以及换行去掉后解 Base64 编码，可得一个压缩文档。解压之后可得一个十分卡顿的 GIF 图片，猜测含有时间隐写。

使用 ImageMagick identify 工具执行 identify -verbose .\flag.gif 并将结果整理后可以得到如下信息。

20 50 50 20 50 50 20 50 20 50 20 20 20 50 20 20 20 20 50 50 20 50 20 50 20 50 20 50 50 50 50 50 20 20 50 50 20 20 20 50 20 50 50 50 20 50 20 20 66 66

将最后的两个 66 去除，将 20 替换成 0，50 替换成 1。再二进制转字符串可得到 mD5_1t。将其 MD5 一次可以得到 f0f1003afe4ae8ce4aa8e8487a8ab3b6。

flag{f0f1003afe4ae8ce4aa8e8487a8ab3b6}

[INSHack2017]10-cl0v3rf13ld-lane-signal

修正所得附件的文件拓展名为 JPG，运行 010 editor 的模板可以很容易看到文件末尾有另外一张 PNG 文件。

将 PNG 文件提取出来得到下图。

在其左下角可以发现小红点，使用摩斯电码解码可得 HELPME。同时在图片的末尾还能发现一个音频文件。

将音频文件提取出来，使用 Audition 打开，可以发现明显的摩斯电码的痕迹，将其抄收下来。

.. -. ... .- -.--. -- ----- .-. ..... ...-- ..--.- .-- .---- .-.. .-.. ..--.- -. ...-- ...- ...-- .-. ..--.- ....- --. ...-- -.-.-- -.--.-

转码后整理即可得到 flag。

INSA{M0R53_W1LL_N3V3R_4G3!}

[GWCTF2019]huyao

附件给出了两张图，猜测是盲水印。在网上找到一段可解出的脚本。

# coding=utf-8
import cv2
import numpy as np
import random
import os
from argparse import ArgumentParser
ALPHA = 5


def build_parser():
    parser = ArgumentParser()
    parser.add_argument('--original', dest='ori', required=True)
    parser.add_argument('--image', dest='img', required=True)
    parser.add_argument('--result', dest='res', required=True)
    parser.add_argument('--alpha', dest='alpha', default=ALPHA)
    return parser


def main():
    parser = build_parser()
    options = parser.parse_args()
    ori = options.ori
    img = options.img
    res = options.res
    alpha = options.alpha
    if not os.path.isfile(ori):
        parser.error("original image %s does not exist." % ori)
    if not os.path.isfile(img):
        parser.error("image %s does not exist." % img)
    decode(ori, img, res, alpha)


def decode(ori_path, img_path, res_path, alpha):
    ori = cv2.imread(ori_path)
    img = cv2.imread(img_path)
    ori_f = np.fft.fft2(ori)
    img_f = np.fft.fft2(img)
    height, width = ori.shape[0], ori.shape[1]
    watermark = (ori_f - img_f) / alpha
    watermark = np.real(watermark)
    res = np.zeros(watermark.shape)
    random.seed(height + width)
    x = range(height / 2)
    y = range(width)
    random.shuffle(x)
    random.shuffle(y)
    for i in range(height / 2):
        for j in range(width):
            res[x[i]][y[j]] = watermark[i][j]
    cv2.imwrite(res_path, res, [int(cv2.IMWRITE_JPEG_QUALITY), 100])


if __name__ == '__main__':
    main()

使用 python2 bwm.py --original huyao.png --image stillhuyao.png --result result.png 可以提取出一张水印图，因此得到了 flag。

GWHT{BWM_1s_c00l}

我爱Linux

附件给出的是一张图片。在其末尾可以得到一串二进制数据。

使用 print(pickle.loads(open("extract.bin", "rb").read())) 处理一下得到如下内容。

[[(3, 'm'), (4, '"'), (5, '"'), (8, '"'), (9, '"'), (10, '#'), (31, 'm'), (32, '"'), (33, '"'), (44, 'm'), (45, 'm'), (46, 'm'), (47, 'm'), (50, 'm'), (51, 'm'), (52, 'm'), (53, 'm'), (54, 'm'), (55, 'm'), (58, 'm'), (59, 'm'), (60, 'm'), (61, 'm'), (66, 'm'), (67, '"'), (68, '"'), (75, '#')], [(1, 'm'), (2, 'm'), (3, '#'), (4, 'm'), (5, 'm'), (10, '#'), (16, 'm'), (17, 'm'), (18, 'm'), (23, 'm'), (24, 'm'), (25, 'm'), (26, 'm'), (31, '#'), (37, 'm'), (38, 'm'), (39, 'm'), (43, '"'), (47, '"'), (48, '#'), (54, '#'), (55, '"'), (57, '"'), (61, '"'), (62, '#'), (64, 'm'), (65, 'm'), (66, '#'), (67, 'm'), (68, 'm'), (72, 'm'), (73, 'm'), (74, 'm'), (75, '#')], [(3, '#'), (10, '#'), (15, '"'), (19, '#'), (22, '#'), (23, '"'), (25, '"'), (26, '#'), (29, 'm'), (30, 'm'), (31, '"'), (36, '"'), (40, '#'), (47, 'm'), (48, '"'), (53, 'm'), (54, '"'), (59, 'm'), (60, 'm'), (61, 'm'), (62, '"'), (66, '#'), (71, '#'), (72, '"'), (74, '"'), (75, '#')], [(3, '#'), (10, '#'), (15, 'm'), (16, '"'), (17, '"'), (18, '"'), (19, '#'), (22, '#'), (26, '#'), (31, '#'), (36, 'm'), (37, '"'), (38, '"'), (39, '"'), (40, '#'), (45, 'm'), (46, '"'), (52, 'm'), (53, '"'), (61, '"'), (62, '#'), (66, '#'), (71, '#'), (75, '#')], [(3, '#'), (10, '"'), (11, 'm'), (12, 'm'), (15, '"'), (16, 'm'), (17, 'm'), (18, '"'), (19, '#'), (22, '"'), (23, '#'), (24, 'm'), (25, '"'), (26, '#'), (31, '#'), (36, '"'), (37, 'm'), (38, 'm'), (39, '"'), (40, '#'), (43, 'm'), (44, '#'), (45, 'm'), (46, 'm'), (47, 'm'), (48, 'm'), (51, 'm'), (52, '"'), (57, '"'), (58, 'm'), (59, 'm'), (60, 'm'), (61, '#'), (62, '"'), (66, '#'), (71, '"'), (72, '#'), (73, 'm'), (74, '#'), (75, '#')], [(23, 'm'), (26, '#'), (32, '"'), (33, '"')], [(24, '"'), (25, '"')], [], [(12, '#'), (17, 'm'), (18, '"'), (19, '"'), (23, 'm'), (24, 'm'), (25, 'm'), (26, 'm'), (33, '#'), (36, 'm'), (37, 'm'), (38, 'm'), (39, 'm'), (40, 'm'), (41, 'm'), (46, 'm'), (47, 'm'), (52, 'm'), (53, 'm'), (54, 'm'), (65, 'm'), (66, 'm'), (67, 'm'), (68, 'm'), (71, 'm'), (72, 'm'), (73, 'm'), (74, 'm'), (75, 'm'), (76, 'm')], [(2, 'm'), (3, 'm'), (4, 'm'), (9, 'm'), (10, 'm'), (11, 'm'), (12, '#'), (15, 'm'), (16, 'm'), (17, '#'), (18, 'm'), (19, 'm'), (22, '"'), (26, '"'), (27, '#'), (30, 'm'), (31, 'm'), (32, 'm'), (33, '#'), (40, '#'), (41, '"'), (45, 'm'), (46, '"'), (47, '#'), (50, 'm'), (51, '"'), (55, '"'), (58, 'm'), (59, 'm'), (60, 'm'), (64, '#'), (65, '"'), (68, '"'), (69, 'm'), (75, '#'), (76, '"')], [(1, '#'), (2, '"'), (5, '#'), (8, '#'), (9, '"'), (11, '"'), (12, '#'), (17, '#'), (24, 'm'), (25, 'm'), (26, 'm'), (27, '"'), (29, '#'), (30, '"'), (32, '"'), (33, '#'), (39, 'm'), (40, '"'), (44, '#'), (45, '"'), (47, '#'), (50, '#'), (51, 'm'), (52, '"'), (53, '"'), (54, '#'), (55, 'm'), (57, '#'), (58, '"'), (61, '#'), (64, '#'), (65, 'm'), (68, 'm'), (69, '#'), (74, 'm'), (75, '"')], [(1, '#'), (2, '"'), (3, '"'), (4, '"'), (5, '"'), (8, '#'), (12, '#'), (17, '#'), (26, '"'), (27, '#'), (29, '#'), (33, '#'), (38, 'm'), (39, '"'), (43, '#'), (44, 'm'), (45, 'm'), (46, 'm'), (47, '#'), (48, 'm'), (50, '#'), (55, '#'), (57, '#'), (58, '"'), (59, '"'), (60, '"'), (61, '"'), (65, '"'), (66, '"'), (67, '"'), (69, '#'), (73, 'm'), (74, '"')], [(1, '"'), (2, '#'), (3, 'm'), (4, 'm'), (5, '"'), (8, '"'), (9, '#'), (10, 'm'), (11, '#'), (12, '#'), (17, '#'), (22, '"'), (23, 'm'), (24, 'm'), (25, 'm'), (26, '#'), (27, '"'), (29, '"'), (30, '#'), (31, 'm'), (32, '#'), (33, '#'), (37, 'm'), (38, '"'), (47, '#'), (51, '#'), (52, 'm'), (53, 'm'), (54, '#'), (55, '"'), (57, '"'), (58, '#'), (59, 'm'), (60, 'm'), (61, '"'), (64, '"'), (65, 'm'), (66, 'm'), (67, 'm'), (68, '"'), (72, 'm'), (73, '"')], [], [], [], [(5, '#'), (8, '#'), (16, 'm'), (17, 'm'), (18, 'm'), (19, 'm'), (23, 'm'), (24, 'm'), (25, 'm'), (26, 'm'), (30, 'm'), (31, 'm'), (32, 'm'), (33, 'm'), (38, 'm'), (39, 'm'), (40, 'm'), (50, '#'), (57, '#'), (64, '#'), (71, 'm'), (72, 'm'), (73, 'm')], [(2, 'm'), (3, 'm'), (4, 'm'), (5, '#'), (8, '#'), (9, 'm'), (10, 'm'), (11, 'm'), (15, '#'), (16, '"'), (19, '"'), (20, 'm'), (22, 'm'), (23, '"'), (26, '"'), (27, 'm'), (29, '#'), (34, '#'), (36, 'm'), (37, '"'), (41, '"'), (44, 'm'), (45, 'm'), (46, 'm'), (50, '#'), (51, 'm'), (52, 'm'), (53, 'm'), (57, '#'), (58, 'm'), (59, 'm'), (60, 'm'), (64, '#'), (65, 'm'), (66, 'm'), (67, 'm'), (73, '#')], [(1, '#'), (2, '"'), (4, '"'), (5, '#'), (8, '#'), (9, '"'), (11, '"'), (12, '#'), (15, '#'), (16, 'm'), (19, 'm'), (20, '#'), (22, '#'), (25, 'm'), (27, '#'), (29, '"'), (30, 'm'), (31, 'm'), (32, 'm'), (33, 'm'), (34, '"'), (36, '#'), (37, 'm'), (38, '"'), (39, '"'), (40, '#'), (41, 'm'), (43, '#'), (44, '"'), (47, '#'), (50, '#'), (51, '"'), (53, '"'), (54, '#'), (57, '#'), (58, '"'), (60, '"'), (61, '#'), (64, '#'), (65, '"'), (67, '"'), (68, '#'), (73, '#')], [(1, '#'), (5, '#'), (8, '#'), (12, '#'), (16, '"'), (17, '"'), (18, '"'), (20, '#'), (22, '#'), (27, '#'), (29, '#'), (33, '"'), (34, '#'), (36, '#'), (41, '#'), (43, '#'), (44, '"'), (45, '"'), (46, '"'), (47, '"'), (50, '#'), (54, '#'), (57, '#'), (61, '#'), (64, '#'), (68, '#'), (73, '#')], [(1, '"'), (2, '#'), (3, 'm'), (4, '#'), (5, '#'), (8, '#'), (9, '#'), (10, 'm'), (11, '#'), (12, '"'), (15, '"'), (16, 'm'), (17, 'm'), (18, 'm'), (19, '"'), (23, '#'), (24, 'm'), (25, 'm'), (26, '#'), (29, '"'), (30, '#'), (31, 'm'), (32, 'm'), (33, 'm'), (34, '"'), (37, '#'), (38, 'm'), (39, 'm'), (40, '#'), (41, '"'), (43, '"'), (44, '#'), (45, 'm'), (46, 'm'), (47, '"'), (50, '#'), (51, '#'), (52, 'm'), (53, '#'), (54, '"'), (57, '#'), (58, '#'), (59, 'm'), (60, '#'), (61, '"'), (64, '#'), (65, '#'), (66, 'm'), (67, '#'), (68, '"'), (71, 'm'), (72, 'm'), (73, '#'), (74, 'm'), (75, 'm')], [], [], [], [(2, 'm'), (3, 'm'), (4, 'm'), (5, 'm'), (8, 'm'), (9, 'm'), (10, 'm'), (11, 'm'), (12, 'm'), (19, '#'), (24, 'm'), (25, 'm'), (26, 'm'), (29, '"'), (30, '"'), (31, 'm')], [(1, '#'), (2, '"'), (5, '"'), (6, 'm'), (8, '#'), (16, 'm'), (17, 'm'), (18, 'm'), (19, '#'), (22, 'm'), (23, '"'), (27, '"'), (31, '#')], [(1, '#'), (2, 'm'), (5, 'm'), (6, '#'), (8, '"'), (9, '"'), (10, '"'), (11, '"'), (12, 'm'), (13, 'm'), (15, '#'), (16, '"'), (18, '"'), (19, '#'), (22, '#'), (23, 'm'), (24, '"'), (25, '"'), (26, '#'), (27, 'm'), (31, '"'), (32, 'm'), (33, 'm')], [(2, '"'), (3, '"'), (4, '"'), (6, '#'), (13, '#'), (15, '#'), (19, '#'), (22, '#'), (27, '#'), (31, '#')], [(1, '"'), (2, 'm'), (3, 'm'), (4, 'm'), (5, '"'), (8, '"'), (9, 'm'), (10, 'm'), (11, 'm'), (12, '#'), (13, '"'), (15, '"'), (16, '#'), (17, 'm'), (18, '#'), (19, '#'), (23, '#'), (24, 'm'), (25, 'm'), (26, '#'), (27, '"'), (31, '#')], [(29, '"'), (30, '"')]]

发现其好像是坐标对应得关系，于是写个脚本将其对应出来。

import pickle

contents = list(pickle.loads(open("extract.bin", "rb").read()))
for content in contents:
    line = list("                                                                             ")
    for (x, y) in content:
        line[x] = y
    print(str(line).replace("\'", "").replace(", ", "").replace("[", "").replace("]", ""))

可以得到如下内容。

   m""  ""#                    m""          mmmm  mmmmmm  mmmm    m""      # 
 mm#mm    #     mmm    mmmm    #     mmm   "   "#     #" "   "# mm#mm   mmm# 
   #      #    "   #  #" "#  mm"    "   #      m"    m"    mmm"   #    #" "# 
   #      #    m"""#  #   #    #    m"""#    m"     m"       "#   #    #   # 
   #      "mm  "mm"#  "#m"#    #    "mm"#  m#mmmm  m"    "mmm#"   #    "#m## 
                       m  #     ""                                           
                        ""                                                   

            #    m""   mmmm      #  mmmmmm    mm    mmm          mmmm  mmmmmm
  mmm    mmm#  mm#mm  "   "#  mmm#      #"   m"#  m"   "  mmm   #"  "m     #"
 #"  #  #" "#    #      mmm" #" "#     m"   #" #  #m""#m #"  #  #m  m#    m" 
 #""""  #   #    #        "# #   #    m"   #mmm#m #    # #""""   """ #   m"  
 "#mm"  "#m##    #    "mmm#" "#m##   m"        #   #mm#" "#mm"  "mmm"   m"   



     #  #       mmmm   mmmm   mmmm    mmm         #      #      #      mmm   
  mmm#  #mmm   #"  "m m"  "m #    # m"   "  mmm   #mmm   #mmm   #mmm     #   
 #" "#  #" "#  #m  m# #  m # "mmmm" #m""#m #"  #  #" "#  #" "#  #" "#    #   
 #   #  #   #   """ # #    # #   "# #    # #""""  #   #  #   #  #   #    #   
 "#m##  ##m#"  "mmm"   #mm#  "#mmm"  #mm#" "#mm"  ##m#"  ##m#"  ##m#"  mm#mm 



  mmmm  mmmmm      #    mmm  ""m                                             
 #"  "m #       mmm#  m"   "   #                                             
 #m  m# """"mm #" "#  #m""#m   "mm                                           
  """ #      # #   #  #    #   #                                             
 "mmm"  "mmm#" "#m##   #mm#"   #                                             
                             ""

flag{a273fdedf3d746e97db9086ebbb195d6}

[XMAN2018排位赛]file

附件给出的是一个镜像，使用 DiskInternals Linux Reader 挂载打开可以发现一个 lost+found 文件夹，说明存在可能可恢复的文件数据碎片。

使用 extundelete attachment.img --restore-all 尝试恢复即可得到一个 Vim 的 swp 文件。将其恢复后整理可得 flag。

flag{fugly_cats_need_luv_2}

[HDCTF2019]信号分析

使用HackCube-Special分析固定码信号：https://www.freebuf.com/articles/wireless/191534.html

将附件使用 Audition 打开可以看到如下重复波形。

根据参考文章的如下图片可以尝试解码。

根据图片规律可解码得到 FFFFFFFF0001。

flag{FFFFFFFF0001}

[De1CTF2019]Mine Sweeping

解压附件可得到一个游戏，使用 dnSpy 查看 Assembly-CSharp.dll 可以找到 OnMouseUpAsButton() 方法，其中存在着判断每次点击是否“踩雷”的操作。要完成游戏只需要点开所有方块即可，因此只需要把“踩雷”去掉。将原有的代码修改如下。

// Elements
// Token: 0x0600000A RID: 10
private void OnMouseUpAsButton()
{
    if (!Grids._instance.bGameEnd && !this.bIsOpen)
    {
        this.bIsOpen = true;
        int num = (int)base.transform.position.x;
        int num2 = (int)base.transform.position.y;
        int adjcent = Grids._instance.CountAdjcentNum(num, num2);
        this.SafeAndThunder(adjcent);
        Grids._instance.Flush(num, num2, new bool[29, 29]);
        if (Grids._instance.GameWin())
        {
            Grids._instance.bGameEnd = true;
            MonoBehaviour.print("game over: win");
        }
    }
}

编译后保存，再次打开游戏并点开所有方块即可得到如下二维码。

扫描二维码可得到 http://qr02.cn/FeJ7dU，访问即可获得 flag。

de1ctf{G3t_F1@g_AFt3R_Sw3ep1ng_M1n3s}

[INSHack2018](not) so deep

使用 Audition 打开附件可以发现半个 flag。

根据其中含有的 st3G4n 推测是隐写，同时题目中有 deep，考虑是 DeepSound。但是没有给出 key，因此尝试使用 john 自带的 deepsound2john.py 来得到 hash 值从而爆破 key。

> python .\run\deepsound2john.py .\final_flag.wav
final_flag.wav:$dynamic_1529$b8f858d9deb0b805797cef03299e3bdd8990f48a

使用 john 爆破可以得到如下结果。

azerty           (final_flag.wav)

因此得到了 key 为 azerty。使用 DeepSound 配合 key 解密可得一个文件。

提取出 flag2.txt 可得后一半 flag 0_1s_4lwayS_Th3_S4me}。

INSA{Aud1o_st3G4n0_1s_4lwayS_Th3_S4me}

[BSidesSF2019]diskimage

附件是一张图片，上半部分显示不正常，考虑有隐写。

在 zsteg 的报告下有如下信息。

b8,rgb,lsb,xy       .. file: DOS/MBR boot sector, code offset 0x3c+2, OEM-ID "~mitsumi", root entries 224, sectors 2880 (volumes <=32 MB) , sectors/FAT 9, sectors/track 18, serial number 0x7e572f0f, unlabeled, FAT (12 bit)

将文件提取出来 zsteg -e 'b8,rgb,lsb,xy' attachment.png > extracted.dat，可以得到一个软盘数据文件。使用 testdisk 指令尝试恢复被删除的文件。

在此界面时按 c 将文件拷贝到软盘数据文件的目录下。恢复得到的 _LAG.ICO 如下。

CTF{FAT12_FTW}

[BSidesSF2020]barcoder

画图一把梭修复条形码，得到如下图片。

使用 bcTester 扫描条形码可得 flag。

CTF{way_too_common}

[CFI-CTF 2018]Kadyrov's Cat

A man from the soviet union has sent you two strange documents. Find the identity of the man as well as his location.

Flag format is : CFI{Firstname_Lastname_of_City}

附件中的图片有经纬度。

稍微计算一下可以得到如下结果。

使用地图可以得到地址 Uzvaras bulvāris, Centra rajons, Rīga, LV-1050, Latvia，因此城市是 Riga。

使用 Acrobat DC 打开附件给出的 PDF 文件可得如下内容。

CFI{Kotik_Kadyrov_of_Riga}

Weird_List

附件给出的是一堆数据，推测其构成了一幅图片。因此写个脚本将数据画出来。

import PIL

pixels = [[120], [120], [24, 1, 87, 1, 7], [7, 1, 15, 1, 21, 1, 16, 1, 49, 1, 7], [2, 1, 1, 1, 2, 1, 15, 1, 4, 1, 3, 1, 1, 1, 10, 1, 16, 1, 4, 1, 1, 1, 2, 1, 1, 1, 19, 1, 7, 1, 1, 1, 2, 1, 1, 1, 3, 1, 6], [2, 1, 1, 1, 3, 1, 14, 1, 3, 1, 1, 1, 2, 1, 1, 1, 10, 1, 16, 1, 4, 1, 1, 1, 2, 1, 1, 1, 18, 1, 8, 1, 1, 1, 2, 1, 1, 1, 4, 1, 5], [2, 1, 1, 1, 3, 1, 14, 1, 3, 1, 1, 1, 2, 1, 1, 1, 10, 1, 16, 1, 4, 1, 1, 1, 2, 1, 1, 1, 17, 1, 1, 1, 7, 1, 1, 1, 2, 1, 1, 1, 4, 1, 5], [2, 1, 5, 1, 14, 1, 3, 1, 1, 1, 4, 1, 10, 1, 16, 1, 7, 1, 4, 1, 16, 1, 1, 1, 7, 1, 2, 1, 4, 1, 3, 1, 5], [2, 1, 5, 1, 14, 1, 3, 1, 2, 1, 4, 1, 9, 1, 16, 1, 7, 1, 4, 1, 16, 1, 1, 1, 10, 1, 4, 1, 3, 1, 5], [2, 1, 5, 1, 3, 1, 1, 1, 2, 1, 5, 1, 3, 1, 2, 1, 4, 1, 1, 1, 5, 1, 1, 1, 2, 1, 9, 1, 3, 1, 2, 1, 4, 1, 4, 1, 1, 1, 1, 1, 7, 1, 1, 1, 4, 1, 3, 1, 6, 1, 4, 1, 3, 1, 5], [2, 1, 5, 1, 3, 1, 1, 1, 2, 1, 1, 1, 3, 1, 3, 1, 2, 1, 3, 1, 2, 1, 4, 1, 1, 1, 2, 1, 1, 1, 7, 1, 1, 1, 2, 1, 1, 1, 5, 1, 4, 1, 1, 1, 1, 1, 7, 1, 1, 1, 4, 1, 3, 1, 1, 1, 4, 1, 4, 1, 3, 1, 5], [2, 1, 5, 1, 3, 1, 1, 1, 2, 1, 1, 1, 3, 1, 3, 1, 2, 1, 3, 1, 2, 1, 4, 1, 1, 1, 2, 1, 9, 1, 4, 1, 1, 1, 5, 1, 3, 1, 2, 1, 2, 1, 6, 1, 2, 1, 3, 1, 2, 1, 2, 1, 4, 1, 4, 1, 3, 1, 5], [2, 1, 1, 1, 3, 1, 5, 1, 2, 1, 1, 1, 3, 1, 3, 1, 2, 1, 2, 1, 8, 1, 1, 1, 2, 1, 9, 1, 4, 1, 1, 1, 4, 1, 3, 1, 6, 1, 6, 1, 2, 1, 3, 1, 2, 1, 2, 1, 4, 1, 2, 1, 5, 1, 5], [2, 1, 1, 1, 3, 1, 6, 1, 1, 1, 1, 1, 2, 1, 4, 1, 1, 1, 3, 1, 3, 1, 4, 1, 1, 1, 2, 1, 9, 1, 4, 1, 1, 1, 4, 1, 3, 1, 6, 1, 6, 1, 2, 1, 3, 1, 2, 1, 2, 1, 3, 1, 3, 1, 5, 1, 5], [2, 1, 5, 1, 6, 1, 1, 1, 4, 1, 4, 1, 1, 1, 3, 1, 3, 1, 4, 1, 2, 1, 1, 1, 9, 1, 4, 1, 6, 1, 3, 1, 6, 1, 6, 1, 2, 1, 3, 1, 2, 1, 2, 1, 3, 1, 3, 1, 1, 1, 4, 1, 4], [2, 1, 5, 1, 3, 1, 1, 1, 2, 1, 4, 1, 4, 1, 1, 1, 4, 1, 2, 1, 4, 1, 2, 1, 1, 1, 9, 1, 4, 1, 6, 1, 4, 1, 3, 1, 1, 1, 6, 1, 2, 1, 3, 1, 2, 1, 2, 1, 3, 1, 5, 1, 3, 1, 5], [2, 1, 5, 1, 3, 1, 1, 1, 2, 1, 5, 1, 3, 1, 1, 1, 5, 1, 2, 1, 3, 1, 2, 1, 2, 1, 9, 1, 3, 1, 1, 1, 3, 1, 6, 1, 1, 1, 1, 1, 7, 1, 2, 1, 3, 1, 2, 1, 2, 1, 3, 1, 5, 1, 3, 1, 5], [2, 1, 5, 1, 3, 1, 2, 1, 1, 1, 5, 1, 4, 1, 1, 1, 4, 1, 1, 1, 4, 1, 2, 1, 2, 1, 9, 1, 3, 1, 1, 1, 3, 1, 6, 1, 1, 1, 2, 1, 6, 1, 2, 1, 3, 1, 2, 1, 2, 1, 2, 1, 6, 1, 3, 1, 5], [2, 1, 5, 1, 3, 1, 2, 1, 1, 1, 5, 1, 6, 1, 4, 1, 6, 1, 2, 1, 3, 1, 9, 1, 2, 1, 1, 1, 3, 1, 6, 1, 1, 1, 2, 1, 6, 1, 2, 1, 3, 1, 2, 1, 2, 1, 2, 1, 6, 1, 3, 1, 5], [2, 1, 5, 1, 3, 1, 1, 1, 2, 1, 1, 1, 3, 1, 6, 1, 4, 1, 1, 1, 4, 1, 2, 1, 4, 1, 9, 1, 1, 1, 1, 1, 3, 1, 6, 1, 1, 1, 2, 1, 6, 1, 2, 1, 3, 1, 2, 1, 2, 1, 2, 1, 6, 1, 3, 1, 5], [2, 1, 5, 1, 3, 1, 1, 1, 2, 1, 1, 1, 3, 1, 5, 1, 5, 1, 6, 1, 1, 1, 5, 1, 9, 1, 1, 1, 1, 1, 2, 1, 7, 1, 1, 1, 2, 1, 6, 1, 2, 1, 3, 1, 2, 1, 2, 1, 1, 1, 7, 1, 3, 1, 5], [2, 1, 5, 1, 3, 1, 1, 1, 2, 1, 1, 1, 3, 1, 5, 1, 4, 1, 2, 1, 1, 1, 2, 1, 1, 1, 17, 1, 2, 1, 1, 1, 6, 1, 2, 1, 1, 1, 7, 1, 2, 1, 3, 1, 2, 1, 2, 1, 1, 1, 4, 1, 2, 1, 3, 1, 5], [2, 1, 5, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 3, 1, 3, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 1, 7, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 1, 7, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 1, 4, 1, 5], [2, 1, 6, 1, 2, 1, 2, 1, 1, 1, 5, 1, 3, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 1, 7, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 1, 7, 1, 1, 1, 3, 1, 1, 1, 2, 1, 3, 1, 1, 1, 2, 1, 1, 1, 4, 1, 5], [12, 1, 5, 1, 4, 1, 4, 1, 3, 1, 10, 1, 4, 1, 9, 1, 14, 1, 4, 1, 8, 1, 1, 1, 8, 1, 9, 1, 4, 1, 6], [19, 1, 4, 1, 62, 1, 24, 1, 7], [19, 1, 4, 1, 62, 1, 24, 1, 7], [17, 1, 1, 1, 31, 1, 1, 1, 1, 1, 25, 1, 1, 1, 1, 1, 1, 1, 32], [17, 1, 1, 1, 31, 1, 1, 1, 1, 1, 25, 1, 1, 1, 1, 1, 1, 1, 32], [17, 1, 1, 1, 67, 1, 32], [120], [21, 1, 1, 1, 1, 1, 86, 1, 1, 1, 1, 1, 3], [120], [120]]
img = PIL.Image.new("RGB", (120, 35), "white")

column, row = 0, 0

for pixelLine in pixels:
    for pixel in pixelLine:
        if pixel > 1:
            column += pixel
        else:
            img.putpixel((int(column), int(row)), (16, 63, 145))
            column += 1
    row += 1
    column = 0

img.save("result.png")

运行脚本可以得到如下图片。

Flag{93ids_sk23a_p1o23}

[NPUCTF2020]回收站

AccessData FTK Imager 挂载附件给出的磁盘，在 X:\Windows\Web\Wallpaper\Windows 下可以找到 flag。除此之外，回收站内也有部分 flag 但是并不完整。

flag{e10adc3949ba59abbe56e057f20f883e}

[INSHack2018]42.tar.xz

套娃解压压缩包即可得到 flag。

也可以脚本一把梭。

while [ "`find . -type f -name '*.tar.xz' | wc -l`" -gt 0 ]; 
do find -type f -name "*.tar.xz" -exec tar xf '{}' \; -exec rm -- '{}' \;; 
done;

INSA{04ebb0d6a87f9771f2eea4dce5b91a85e7623c13301a8007914085a91b3ca6d9}

[SWPU2019]Android1

解压文件之后发现一个库，使用 IDA 打开可以发现四个奇怪的函数，其代码整理后如下。

char *aa(void)
{
  char *result; // rax
  signed int i; // [rsp+Ch] [rbp-14h]
  char v2[3]; // [rsp+11h] [rbp-Fh]
  int v3; // [rsp+14h] [rbp-Ch]
  unsigned __int64 v4; // [rsp+18h] [rbp-8h]

  v4 = __readfsqword(0x28u);
  v3 = 'R_C';
  for ( i = 0; i < 3; ++i )
    v2[i] = *((_BYTE *)&v3 + i) ^ 0x37;
  result = v2;
  if ( __readfsqword(0x28u) == v4 )
    result = v2;
  return result;
}

char *aA(void)
{
  char *result; // rax
  signed int i; // [rsp+Ch] [rbp-14h]
  char v2[3]; // [rsp+11h] [rbp-Fh]
  int v3; // [rsp+14h] [rbp-Ch]
  unsigned __int64 v4; // [rsp+18h] [rbp-8h]

  v4 = __readfsqword(0x28u);
  v3 = 'AVE';
  for ( i = 0; i < 3; ++i )
    v2[i] = *((_BYTE *)&v3 + i) ^ 0x24;
  result = v2;
  if ( __readfsqword(0x28u) == v4 )
    result = v2;
  return result;
}

char *Aa(void)
{
  char *result; // rax
  signed int i; // [rsp+Ch] [rbp-14h]
  char v2[3]; // [rsp+11h] [rbp-Fh]
  int v3; // [rsp+14h] [rbp-Ch]
  unsigned __int64 v4; // [rsp+18h] [rbp-8h]

  v4 = __readfsqword(0x28u);
  v3 = 'MWa';
  for ( i = 0; i < 3; ++i )
    v2[i] = *((_BYTE *)&v3 + i) ^ 0x38;
  result = v2;
  if ( __readfsqword(0x28u) == v4 )
    result = v2;
  return result;
}

char *AA(void)
{
  char *result; // rax
  signed int i; // [rsp+Ch] [rbp-14h]
  char v2[3]; // [rsp+10h] [rbp-10h]
  int v3; // [rsp+13h] [rbp-Dh]
  char v4; // [rsp+17h] [rbp-9h]
  unsigned __int64 v5; // [rsp+18h] [rbp-8h]

  v5 = __readfsqword(0x28u);
  v3 = '#$D5';
  v4 = 0;
  for ( i = 0; i < 4; ++i )
    v2[i] = *((_BYTE *)&v3 + i) ^ 0x77;
  result = v2;
  if ( __readfsqword(0x28u) == v5 )
    result = v2;
  return result;
}

写个脚本跑出结果。

#include <iostream>
using namespace std;

int main(){
    string aa = "R_C"; //0x37
    string aA = "AVE"; //0x24
    string Aa = "MWa"; //0x38
    string AA = "#$D5"; //0x77
    string result = "";
    for(char c : AA){
        result += c ^ 0x77;
    }
    for(char c : aa){
        result += c ^ 0x37;
    }
    for(char c : aA){
        result += c ^ 0x24;
    }
    for(char c : Aa){
        result += c ^ 0x38;
    }
    reverse(result.begin(),result.end());
    cout << result;
}

得到 flag。

flag{YouaretheB3ST}

[BSidesSF2020]toast-clicker1

使用 jadx 反编译附件可得到如下代码。

int[] input = {67, 83, 68, 120, 62, 109, 95, 90, 92, 112, 85, 73, 99, 82, 53, 99, 101, 92, 80, 89, 81, 104};
public String printfirstFlag() {
    String output = BuildConfig.FLAVOR;
    int i = 0;
    while (true) {
        int[] iArr = this.input;
        if (i >= iArr.length) {
            return output;
        }
        output = output + Character.toString((char) (iArr[i] + i));
        i++;
    }
}

写个脚本把上述代码复刻一遍，得到 flag。

input = [67, 83, 68, 120, 62, 109, 95, 90, 92, 112, 85, 73, 99, 82, 53, 99, 101, 92, 80, 89, 81, 104]
output = ""
for x in range(len(input)):
    output += chr(x + input[x])
print(output)

CTF{Bready_To_Crumble}

[*CTF2019]babyflash

JPEXS Free Flash Decompiler 反编译一下 swf 文件可以得到 441 张图片，这个数量正好是 21 的平方，考虑一下是二维码。

将所有图片文件名使用 dir /b 提取出来并排好序，然后使用指令 for /f "skip=1" %%a in (files.txt) do certutil -hashfile %%a MD5>>md5.txt 计算出图片的 MD5。补全第一个图片的 MD5 后整理可得如下内容。

111111100110001111111100000100111001000001101110101011001011101101110100100101011101101110100101101011101100000100110001000001111111101010101111111000000001010100000000111011111011111000100110110011011101111011101101111001101111011010010001100000000011111010100000100011000000000001011100110011111111101011100110101100000101101000100010101110101011011000001101110100101101110000101110101101110110001100000101011100010010111111101101100001011

可使用如下 receipt 得到前半段 flag。

Find_/_Replace({'option':'Regex','string':'0'},'\\xFF',true,false,true,false)
Find_/_Replace({'option':'Regex','string':'1'},'\\x00',true,false,true,false)
Generate_Image('Greyscale',12,21)
Parse_QR_Code(false)

*ctf{half_flag_&

将 swf 文件中的音频也导出，使用 Audition 打开后可看到如下内容。

得到 flag。

*ctf{half_flag_&&_the_rest}

- *ctf{half_flag_&&_the_rest} // original
+ flag{halfflag&&_the_rest} // flag for BUUOJ

[INSHack2018]GCorp - Stage 1

使用 Wireshark 分析流量包，跟踪 TCP 流，可以在最后找到如下信息。

SU5TQXtjMTgwN2EwYjZkNzcxMzI3NGQ3YmYzYzY0Nzc1NjJhYzQ3NTcwZTQ1MmY3N2I3ZDIwMmI4MWUxNDkxNzJkNmE3fQ==

将其 Base64 解码一次即可得到 flag。

INSA{c1807a0b6d7713274d7bf3c6477562ac47570e452f77b7d202b81e149172d6a7}

[HarekazeCTF2019]A_Z

/source 页面中可以找到如下关键代码片段。

app.get('/', function (req, res, next) {
  let output = '';
  const code = req.query.code + '';
  if (code && code.length < 200 && !/[^a-z().]/.test(code)) {
    try {
      const result = vm.runInNewContext(code, {}, { timeout: 500 });
      if (result === 1337) {
        output = process.env.FLAG;
      } else {
        output = 'nope';
      }
    } catch (e) {
      output = 'nope';
    }
  } else {
    output = 'nope';
  }
  res.render('index', { title: '[a-z().]', output });
});

因此关键在于如何使用限定的字符集 a-z(). 构造出 1337 这个数。通过尝试可以发现如下几点。

(typeof(self)) // object
(typeof(self)).constructor.length // 1
NaN.constructor.length // 1
true.constructor.length // 1
(typeof(self)).sub.name.length // 3
(typeof(self)).replace.name.length //7

因此可以构造出如下载荷。

eval(((typeof(self)).constructor()).concat(true.constructor.length).concat((typeof(self)).sub.name.length).concat((typeof(self)).sub.name.length).concat((typeof(self)).replace.name.length))

将载荷提交即可得到 flag。

flag{8d58e39a-55b3-45b3-a0f4-c297774e4077}

[网鼎杯 2020 青龙组]虚幻2

检测附件的类型可知是一张图片。

File type:   Portable Network Graphics image
Extension:   png
MIME type:   image/png

猜测是三个颜色通道信息的叠合，同时看结构很像是汉信码。写个脚本将内容还原一下。

from PIL import Image

image = Image.open('file.png')
pixels = ''
for i in range(0, 36):
    for j in range(0, 12):
        pixel = image.getpixel((i, j))
        for k in range(0, 3):
            pixels += ('1' if pixel[k] == 0 else '0')
print(pixels)

运行脚本可以得到如下内容。

000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011111110000110111111110011111110000010000000001100111101100000000010000010111110000000110110110011111010000010100000001010100111111000001010000010101110001010110110001011101010000010101110010010101010000011101010000010101110100110100010000011101010000000000000101010101111001000000000000000000000000010101001100111011000000001101100011010110000000100100100000001111101010000101010011100000110000010101000010110111111001111000000000010001101001100110011001111110000000000000000000000110001000001111000000011111111111111111110010010001010000011101001001000010110000111101000000011101010000101101110011010110100000010101010100110111001110010001110000010000101100001000101111000011110000011010110000111111101110100101110000011011011110010011110111101100010000011101001110010100001011001000110000000110111000100110111010000000000000000000000101110101111101000000000000010101110001111000000000011101010000010101110010000000000000011101010000010101110101011000000000011101010000010100000100000000000000000001010000010111110010110000000000011111010000010000000000000000000000000000010000011111110011000000000000011111110000000000000000000000000000000000000000000000000000000000000000000000000

使用如下的 CyberChef Receipt 可以生成图片。

Find_/_Replace({'option':'Regex','string':'1'},'\\x00',true,false,true,false)
Find_/_Replace({'option':'Regex','string':'0'},'\\xff',true,false,true,false)
Generate_Image('Greyscale',8,36)

将图片稍微处理一下，再填充一下空白处，使用汉信码的 app 扫描即可得到 flag。

flag{eed70c7d-e530-49ba-ad45-80fdb7872e0a}

[INSHack2019]Passthru

用 Wireshark 载入附件中的 sslkey 后分析流量包，可以发现很多含有 kcahsni 的请求，将其反写可得 inshack，因此推测其与 flag 相关。使用 tshark 将请求的参数内容取出。

tshark -r capture.pcap -o "tls.keylog_file:sslkey.log" -Y "http contains \"GET /searchbyimage\"" -T fields -e http.request.uri.query.parameter > data.txt

将取出的数据使用如下 CyberChef Receipt 处理即可得到含有 flag 的字符串。

URL_Decode()
Find_/_Replace({'option':'Regex','string':'^i(.*)&kcahsni='},'',true,false,true,false)
Find_/_Replace({'option':'Regex','string':',(.*)$\\n'},'',true,false,true,false)
From_Hex('Auto')
Reverse('Character')

INSA{b274dddb2c7707ebe430dadcf1245c246713502d6e9579f00acd10a83f3da95e}

[INSHack2019]Crunchy

附件给出的代码如下。

def crunchy(n):
    if n < 2: return n
    return 6 * crunchy(n - 1) + crunchy(n - 2)

g = 17665922529512695488143524113273224470194093921285273353477875204196603230641896039854934719468650093602325707751568

print("Your flag is: INSA{%d}"%(crunchy(g)%100000007))

由于数字太大导致递归超出了范围，尝试用 SageMath 来解出。SageMath 中提供了一个包可以用来快速算出斐波那契数列。

https://doc.sagemath.org/html/en/reference/combinat/sage/combinat/binary_recurrence_sequences.html

此时只需要写个脚本解出答案即可。

g = 17665922529512695488143524113273224470194093921285273353477875204196603230641896039854934719468650093602325707751568
modNum = 100000007
binaryRecurrenceSequence = BinaryRecurrenceSequence(6, 1)
period = binaryRecurrenceSequence.period(modNum)
print(binaryRecurrenceSequence(g % period) % modNum)

INSA{41322239}

[WMCTF2020]行为艺术

附件给出了一张图片，010 打开运行模板得到 CRC Mismatch 提示后根据 hex: 0x380 0x284 修正其高度，即可得到下图。

略微读一下内容很容易发现图片的数字中有一个压缩文档，将图片内容转写下来得到如下信息。

504B0304140000000800DB93C55086A39007D8000000DF01000008000000666C61672E74787475504B0E823010DD93708771DDCCB0270D5BBD0371815A9148AC6951C2ED9D271F89C62E2693D7F76BB7DE9FC80D2E6E68E782A326D2E01F81CE6D55E76972E9BA7BCCB3ACEF7B89F7B6E90EA16A6EE2439D45179ECDD1C5CCFB6B9AA489C1218C92B898779D765FCCBB58CC920B6662C5F91749931132258F32BBA7C288C5AE103133106608409DAC419F77241A3412907814AB7A922106B8DED0D25AEC8A634929025C46A33FE5A1D3167A100323B1ABEE4A7A0708413A19E17718165F5D3E73D577798E36D5144B66315AAE315078F5E51A29246AF402504B01021F00140009000800DB93C55086A39007D8000000DF010000080024000000000000002000000000000000666C61672E7478740A00200000000000010018004A0A9A64243BD601F9D8AB39243BD6012D00CA13223BD601504B050600000000010001005A000000FE00000000000000

使用如下的 CyberChef Receipt 可得到下一步的信息。

From_Hex('None')
Unzip('',false)
Decode_text('UTF-8 (65001)')

Good eyes! Here is your flag:
https://www.splitbrain.org/services/ook

+++++ ++++[ ->+++ +++++ +<]>+ +++++ .<+++ [->-- -<]>- .<+++ [->-- -<]>-
.<+++ +[->+ +++<] >+.<+ ++[-> ---<] >---- -.<++ +++++ [->++ +++++ <]>++
++.-- --.<+ +++[- >---- <]>-- ----. +++++ +++.< +++[- >---< ]>-.+ ++.++
+++++ .<+++ [->-- -<]>- .+++. -.... --.++ +.<++ +[->+ ++<]> ++++. <++++
++++[ ->--- ----- <]>-- ----- ----- --.<+ +++[- >++++ <]>+. +...< +++++
+++[- >++++ ++++< ]>+++ +++++ +++.. .-.<

使用信息中的网站进行 Brainfuck to Text 可得 flag。

WMCTF{wai_bi_baaaa_bo!2333~~~}

[羊城杯 2020]逃离东南亚

附件解压后得到三个日记压缩文档，第一个打开后有一张图片。010 editor 打开后可知需要修复图片宽高。将其依照脚本爆破结果 hex: 0xf9 0x12c 修复后可得下图。

将 wdnmd 作为压缩包密码解压日记 2 压缩文档可得一串 Brainfuck 和一个音频。在 Brainfuck 前面补充上 8 个 + 即可解码成功并得到一串 Base64。使用 CyberChef 解码后检测文件类型可知其是一个 ELF 文件。

File type:   Executable and Linkable Format
Extension:   elf,bin,axf,o,prx,so
MIME type:   application/x-executable
Description: Executable and Linkable Format file. No standard file extension.

将其用 IDA 打开可以得到如下源码。

int __cdecl main(int argc, const char **argv, const char **envp)
{
  puts("hei~what you want??");
  sleep(1u);
  puts("want a flag? ");
  sleep(1u);
  puts("sorry~there is no flag");
  sleep(1u);
  puts("but maybe your can find something useful!");
  return 0;
}

音频中考虑存在隐写，因此尝试使用 SilentEye 尝试 Decode，得到了如下信息。

使用 This1sThe3rdZIPpwd 作为密码解压日记 3。可以得到一份日记和 libc 的源码。从 NEWS 中可以得到版本信息 Version 2.28。从 GitHub 上下载对应的源码，然后用 Diff Merge 做比对。根据日记中的暗示可以知道信息留存在代码中，因此比对一下更改即可。

https://github.com/bminor/glibc/tree/3c03baca37fdcb52c3881e653ca392bba7a99c2b

可以发现有一个文件的代码里增加了很多空格。此时再换到 Beyond Compare 比对一下可以得到如下结果，猜测这些空格中确实隐藏了信息。

使用如下的 CyberChef Receipt 可以得到其中的信息。

Diff('\\n\\n\\n\\n\\n','Character',true,true,true,false)
Find_/_Replace({'option':'Regex','string':' '},'0',true,false,false,false)
Find_/_Replace({'option':'Regex','string':'\\t'},'1',true,false,true,false)
Find_/_Replace({'option':'Regex','string':'\\n'},'',true,false,true,false)
Find_/_Replace({'option':'Regex','string':'000000000'},'',true,false,true,false)
From_Binary('None',8)

//Extract from arena.c
your flag is in malloc.c

//Extract from rtld.c
SOS! please help me -> rtld.c

对 malloc.c 提取信息可得 flag。

GWCTF{code_steganography_1s_funny!}

[RCTF2019]printer

Wireshark 分析流量包，可得如下内容，

BAR 348, 439, 2, 96 
BAR 292, 535, 56, 2 
BAR 300, 495, 48, 2 
BAR 260, 447, 2, 88 
BAR 204, 447, 56, 2 
BAR 176, 447, 2, 96 
BAR 116, 455, 2, 82 
BAR 120, 479, 56, 2 
BAR 44, 535, 48, 2 
BAR 92, 455, 2, 80 
BAR 20, 455, 72, 2 
BAR 21, 455, 2, 40 
BAR 21, 495, 24, 2 
BAR 45, 479, 2, 16 
BAR 36, 479, 16, 2 
BAR 284, 391, 40, 2 
BAR 324, 343, 2, 48 
BAR 324, 287, 2, 32 
BAR 276, 287, 48, 2 
BAR 52, 311, 48, 2 
BAR 284, 239, 48, 2 
BAR 308, 183, 2, 56 
BAR 148, 239, 48, 2 
BAR 196, 191, 2, 48 
BAR 148, 191, 48, 2 
BAR 68, 191, 48, 2 
BAR 76, 151, 40, 2 
BAR 76, 119, 2, 32 
BAR 76, 55, 2, 32 
BAR 76, 55, 48, 2 
BAR 112, 535, 64, 2 
BAR 320, 343, 16, 2 
BAR 320, 319, 16, 2 
BAR 336, 319, 2, 24 
BAR 56, 120, 24, 2 
BAR 56, 87, 24, 2 
BAR 56, 88, 2, 32 
BAR 224, 247, 32, 2 
BAR 256, 215, 2, 32 
BAR 224, 215, 32, 2 
BAR 224, 184, 2, 32 
BAR 224, 191, 32, 2 
BAR 272, 311, 2, 56 
BAR 216, 367, 56, 2 
BAR 216, 319, 2, 48 
BAR 240, 318, 2, 49 
BAR 184, 351, 2, 16 
BAR 168, 351, 16, 2 
BAR 168, 311, 2, 40 
BAR 152, 351, 16, 2 
BAR 152, 351, 2, 16

根据提示可找到打印机的文档。

http://www.kroyeuropedownload.com/English_User_Manuals/TSPL_TSPL2_Programming_Jan_2017.pdf

根据规则使用 Python 将图片画出来。

from PIL import Image

barcmds = [cmd.replace("BAR", "").strip().split(",") for cmd in open("barcmds", "r").readlines()]
image = Image.new("RGB", (500, 600), "white")

for cmd in barcmds:
    bar = Image.new("RGB", (int(cmd[2]), int(cmd[3])), (16, 63, 145))
    image.paste(bar, (int(cmd[0]), int(cmd[1])))
image = image.rotate(180)
image.save("result.png")

得到如下图片。

流量中还包含了 bitmap 的数据，根据文档中的描述可知其结构。

因此将指定部分数据提取出来后用如下 CyberChef Receipt 处理即可得到剩下部分的 flag。

From_Hex('Auto')
To_Binary('None',8)
Find_/_Replace({'option':'Regex','string':'0'},'\\x00',true,false,true,false)
Find_/_Replace({'option':'Regex','string':'1'},'\\xff',true,false,true,false)
Generate_Image('Greyscale',1,208)
Rotate_Image(180)

flag{my_tsc_hc3pnikdk}

[b01lers2020]matryoshka

附件给出的图片中有不同向的草莓，使用脚本将数据处理一下然后使用 CyberChef 重新渲染图片。

from PIL import Image

image = Image.open("matryoshka.png")
offset = 12
for x in range(offset, image.width, 50):
    for y in range(offset, image.height, 50):
        (r, g, b) = image.getpixel((x, y))
        print(1 if r != 0 else 0, end="")

Find_/_Replace({'option':'Regex','string':'1'},'\\xFF',true,false,true,false)
Find_/_Replace({'option':'Regex','string':'0'},'\\x00',true,false,true,false)
Generate_Image('Greyscale',2,121)

得到了一个二维码。

使用如下工具扫描可得一个 GZIP 文件。

https://online-barcode-reader.inliteresearch.com/

使用如下的 CyberChef Receipt 处理可以得到一个二维码。

From_Hexdump()
Gunzip()
Find_/_Replace({'option':'Regex','string':'l'},'\\xFF',true,false,true,false)
Find_/_Replace({'option':'Regex','string':'1'},'\\x00',true,false,true,false)
Generate_Image('Greyscale',2,86)

再次扫描得出的二维码后用如下 CyberChef Receipt 处理可得到又一个二维码。

From_Hexdump()
Render_Image('Raw')
Invert_Image()

再次扫描二维码后可得一个 7z 文件的数据，稍微处理后将其打开。使用弱密码尝试可得压缩包密码为 1234。将压缩包解压即可得到 flag。

pctf{dolls_do_get_boring_after_a_while}

[NPUCTF2020]OI的梦

矩阵快速幂可以解决，很容易找到如下代码示例。稍微修改一下示例的代码。

https://blog.csdn.net/bianxia123456/article/details/105167294/

def mulMatrix(x, y):
    ans = [[0 for i in range(101)] for j in range(101)]
    for i in range(101):
        for j in range(101):
            for k in range(101):
                ans[i][j] += x[i][k] * y[k][j]
                ans[i][j] %= 10003
    return ans


def quickMatrix(m, n):
    E = [[0 for i in range(101)] for j in range(101)]
    for i in range(101):
        E[i][i] = 1
    while (n):
        if n % 2 != 0:
            E = mulMatrix(E, m)
        m = mulMatrix(m, m)
        n >>= 1
    return E


matrix = [[0 for i in range(101)] for j in range(101)]
dataIn = open("yyh.in", "r").readlines()
n, m, steps = dataIn[0].strip().split()
m = int(m)
for x in range(0, m):
    i, j = dataIn[x + 1].strip().split()
    i = int(i)
    j = int(j)
    matrix[i][j] = 1
    matrix[j][i] = 1
ans = quickMatrix(matrix, int(steps))
print(ans[1][int(n)])

flag{5174}

[INSHack2017]smart-sensors-api

题目给出的是一个 .git 文件夹，git restore 还原一下可以得到一些代码。查看 log 之后使用指令 git diff ef45d97c8fe2c8ff03192d2ec96570dd0edbad01 比对可以得到如下关键信息。

-[APP]
-debug=false
-locale=fr_FR.UTF-8
-
-
-[USER]
-api_key=EF6960F6128EB18B861320D5622A79B33DE717B60278888C89DFAB82403CADD641C662EBBAF05D4FC5CC2EDD1CB5F667B6E540EE7ECFA053F5E4C70C803BC928

到这里获得了 api_key，之后的步骤是使用 api_key 请求 API。

[BSidesSF2019]delta

将附件中图片的缩略图使用 exiftool -b -ThumbnailImage attachment.jpg > extract3.jpg 提取出来之后使用 Beyond Compare 进行比较可以得到下图。

https://en.wikipedia.org/wiki/Code_128

参考 Wikipedia 的做法，The width of each bar or space may be 1, 2, 3 or 4 units (modules).，将条码转写成如下数字。

2112141313212134111323114121214131111421122411121421124131111122141222311422111112421221141113411212412331112

对照 Start Code 211214 可知应该用 128B 来解码其中的内容。同时数字尾部的 2331112 是 Stop pattern，因此需要解码的主要是中间的内容。将其对照码表部分解码后可得 flag。

CTF{minime.jpg}

[羊城杯 2020]signin

https://eprint.iacr.org/2020/301.pdf

MadHatter cipher，其密码表如下。

将密码表倒序得到本题的密码表。

ACEG Y
ACEH X
ACEI W
ACFG V
ACFH U
ACFI S
ADEG Q
ADEH P
ADEI O
ADFG N
ADFH L
ADFI K
BCEG I
BCEH G
BCEI F
BCFG C
BCFH B
BCFI R
BDEG E
BDEH T
BDEI H
BDFG D
BDFH A
BDFI H

将附件中的信息四位一组按照上述密码表转写，即得到 flag。

GWHT{TOYSAYGREENTEAISCOOL}

[羊城杯 2020]TCP_IP

使用 tshark.exe -r attachment.pcap -T fields -e ip.id > data.txt 将流量包中 TCP 流量的 Identification 提取出来可以得到如下内容。

0x00000040
0x00000069
0x00000048
0x0000003c
0x0000002c
0x0000007b
0x0000002a
0x0000003b
0x0000006f
0x00000055
0x00000070
0x0000002f
0x00000069
0x0000006d
0x00000022
0x00000051
0x00000050
0x0000006c
0x00000060
0x00000079
0x00000052
0x0000002a
0x00000069
0x00000065
0x0000007d
0x0000004e
0x0000004b
0x0000003b
0x0000002e
0x00000044
0x00000021
0x00000058
0x00000075
0x00000029
0x00000062
0x0000003a
0x0000004a
0x0000005b
0x00000052
0x0000006a
0x0000002b
0x00000036
0x0000004b
0x0000004b
0x0000004d
0x00000037
0x00000050
0x00000040
0x00000069
0x00000048
0x0000003c
0x0000002c
0x0000007b
0x0000002a
0x0000003b
0x0000006f
0x00000055
0x00000070
0x0000002f
0x00000069
0x0000006d
0x00000022
0x00000051
0x00000050
0x0000006c
0x00000060
0x00000079
0x00000052

使用如下的 Cyberchef Receipt 处理上述内容可以得到如下内容。

Find_/_Replace({'option':'Simple string','string':'0x000000'},'',true,false,true,false)
From_Hex('Auto')

@iH<,{*;oUp/im"QPl`yR*ie}NK;.D!Xu)b:J[Rj+6KKM7P@iH<,{*;oUp/im"QPl`yR

将上述字符串循环的部分去除后使用 Base 91 解码即可得到 flag。

flag{wMt84iS06mCbbfuOfuVXCZ8MSsAFN1GA}

[RoarCTF2019]davinci_cipher

使用 Wireshark 分析流量包可得其中含有设备 Wacom Intuos Pro M 的 USB 流量。使用 tshark.exe -r k3y.pcapng -T fields -e usb.capdata > data.txt 将其提取出来后筛选出数位板的流量。对照 USB 协议的文档可以找到如下描述。

因此写个脚本将流量中的坐标表示出来。

from PIL import Image

data = open("F:/CTFs/2021/Archived/BUUCTF Misc/[RoarCTF2019]davinci_cipher/data.txt").read().split("\n")

image = Image.new("RGB", (347, 239), "white")

for line in data:
    x0 = int(line[4:6], 16)
    x1 = int(line[6:8], 16)
    x = x0 + x1 * 256
    y0 = int(line[10:12], 16)
    y1 = int(line[12:14], 16)
    y = y0 + y1 * 256
    x //= 100
    y //= 100
    image.putpixel((x, -y), (16, 63, 145))
image = image.transpose(Image.FLIP_TOP_BOTTOM)
image.save("result.png")

可以得到如下图片。

将 flag.txt 中的字符串经过 Unicode 解码后可得如下内容。

🙃💵🌿🎤🚪🌏🐎🥋🚫😆🎃🦓✉🌿📂☃👉🛩✅🎅⌨🌏🛩🚨🤣💧🎃🍍😁ℹ📂🚫👣😀👣🙃🎤⌨😁🤣🎤🕹👑🚪🍴🕹😇🍴🐎✅✉🌏⏩🐍🚨☀😇🏹👁👣✉🌊🚨✖

使用 MONA_LISA_IS_A_MAN 作为 key 解 emoji-aes 可得 flag。

RoarCTF{wm-m0de3n_dav1chi}

[NPUCTF2020]HappyCheckInVerification

将附件的文件尾从文件头部移回去后修正文件的伪加密，可以解压得到一张图片和一个视频。将缺少定位点的二维码修复可得如下内容。

flag{this_is_not_flag}三曳所諳陀怯耶南夜缽得醯怯勝數不知喝盧瑟侄盡遠故隸怯薩不娑羯涅冥伊盧耶諳提度奢道盧冥以朋罰所即栗諳蒙集皤夷夜集諳利顛呐寫無怯依奢竟#￥#%E68BBFE4BD9BE68B89E6A0BCE79A84E5A7BFE58ABFE59CA8E69C80E5908E32333333||254333254242254338254342254231254338254345254432254238254643254236254145254239254441254437254234254232254131254236254245253244253244254343254438254330254341254336254435.sadwq#asdsadasf faf$use$dasdasdafafa_$ba##se64$

将内容依次解码可在中间部分找到重要提示 拿佛拉格的姿势在最后2333，而字符串的最后有 use base64 的提示。将视频中的 DTMF 音频处理后可得 448070885。之后的步骤大概是向出题人获取 hint 后从公众号获得一份音频。这里从别的师傅的 WriteUp 上获得了这份音频，使用 RX-SSTV 接收可得下图。

flag{miSc_ChecK_In_Ver16ied}

[XMAN2018排位赛]ppap

Wireshark 打开流量包，跟踪到 TCP 流 6 可以获得一串 Base64，将其分段后分别解码可以得到一张图片，一个 xml 文件，一个加密的包含 flag 的压缩包，以及如下提示。

yaaaaaaaar, land ho!Hey wesley, you got that flag?Ayy, I got yer files right here, matey!

And here be the map to the booty!

I don't understand, this isn't even a ma-Yarrrr, the booty be buried by that which the map points to! (no spaces and no caps)Ayy, now I be off. But remember, the factor of scales be 1.02, and the neighborly sorts be limited to 50! Lastly, if ye sail the seven seas, you do be a pirate!

将图片 foremost 之后可以得到很多图片，根据提示可以知道需要找一张 pirate 的图片。很容易可以找到如下图片。

但是我没懂为啥解压密码就是 skullandcrossbones 了。解压上述得到的压缩文档即可得到 flag。

flag{b31Ng_4_P1r4tE_1s_4lR1GHT_w1Th_M3}

[SUCTF2018]dead_z3r0

将附件的头部的字符串删除，可以得到一个 pyc 文件，将其反编译可以得到如下代码。

#! /usr/bin/env python 3.6 (3379)
#coding=utf-8
# Compiled at: 2018-11-01 06:20:56
#Powered by BugScaner


def encryt(key, plain):
    cipher = ''
    for i in range(len(plain)):
        cipher += chr(ord(key[i % len(key)]) ^ ord(plain[i]))

    return cipher


def getPlainText():
    plain = ''
    with open('plain.txt') as (f):
        while True:
            line = f.readline()
            if line:
                plain += line
            else:
                break

    return plain


def main():
    key = 'LordCasser'
    plain = getPlainText()
    cipher = encryt(key, plain)
    with open('cipher.txt', 'w') as (f):
        f.write(cipher.encode('base_64'))


if __name__ == '__main__':
    main()

将之前删除的 Base64 字符串作为参数传入，写一段逆算法解码内容。

import base64
import urllib.parse


def decryt(key, cipher):
    plain = ''
    cipher = base64.b64decode(cipher)
    for i in range(len(cipher)):
        plain += chr(ord(key[i % len(key)]) ^ cipher[i])
    return plain


def main():
    key = 'LordCasser'
    cipher = "KTswVQk1OgQrOgUVODAKFikZJAUuKzwPCTUxMQE1Kxc8NxYYPjcgQwY7OxMhCzFDLyYFGBYjKwkXMDALAScZEycyJgooOigHEAoSDT42IEcBLCcdDiUxBi8mBRgoLBUKPgowBR04P1QnJj0cLyYFGBYjJBs5JywFL1wjHhkbMkI8KhoWFjAWXH55"
    plain = decryt(key, cipher)
    plain = base64.b64decode(plain).decode()
    print(urllib.parse.unquote(plain))


if __name__ == '__main__':
    main()

运行脚本可以得到如下内容。

y0u 4r3 f00l3d
th15 15 n0t that y0u want
90 0n dud3
c4tch th3 st3g05auru5

使用 Stegosaurus 对 pyc 文件解隐写可以得到 flag。

SUCTF{Z3r0_fin411y_d34d}

一路到底

写个脚本遍历文件将内容取出并转化为对应格式。

result = ""
count = 0

data = open("F:/CTFs/2021/Archived/BUUCTF Misc/一路到底/38ff11ef-e3d3-4f8a-b163-3d300bc016ea/files/start.txt").read()
next = data[-36:]
result += "{:04x}".format(int(data[0:data.find(':') - 1]))
count += 1
print(count, next)
while True:
    try:
        data = open(f"F:/CTFs/2021/Archived/BUUCTF Misc/一路到底/38ff11ef-e3d3-4f8a-b163-3d300bc016ea/files/{next}").read()
        next = data[-36:]
        result += "{:04x}".format(int(data[0:data.find(':') - 1]))
        count += 1
        print(count, next)
    except:
        break

open("F:/CTFs/2021/Archived/BUUCTF Misc/一路到底/38ff11ef-e3d3-4f8a-b163-3d300bc016ea/result.txt", "w").write(result)

十六进制转换一次可以得到一个压缩文档，爆破其密码可以得到解压密码为 tgb678。压缩包解压可得一张图片，修正文件头后打开即可得到 flag。

flag{0c6b489ca956e2fd94dce12be4bf0729}

[b01lers2020]minecraft_purdue

将存档导入游戏内，启动游戏可以进入地图。在门口找到如下提示。

可以在一栋建筑内找到 flag。

pctf{M1NE}

[NPUCTF2020]签到

根据红石灯的亮与灭来得到如下摩斯电码。

..---..-.--....-..---..-

使用如下的 Cyberchef Receipt 来处理可以得到 flag。

Find_/_Replace({'option':'Simple string','string':'.'},'0',true,false,true,false)
Find_/_Replace({'option':'Simple string','string':'-'},'1',true,false,true,false)
From_Binary('Space',8)
MD5()
To_Upper_case('All')
To_Upper_case('All')

flag{8F108D05D23041B5866F9CB2FF109661}

[HackIM2020]ZeldaInSpace

After conquering on land.Zelda is stuck in another dimensionin Space.He will be stuck here till he solves the puzzle that thedark lord has tested him with. 2 platforms are connected with multiple paths between them.There are 6 weird buttons in Space, walking over which makesup a key of sorts.Help Zelda solve the Space Puzzle.

根据题目描述可知要在游戏中按照顺序找到几个按钮。使用 dnSpy 分析 Assembly-CSharp 可得如下代码。

private void OnGUI()
    {
        StringBuilder stringBuilder = new StringBuilder();
        string text = stringBuilder.ToString();
        if (this.checkpoints.Count >= 1)
        {
            foreach (string value in this.checkpoints)
            {
                stringBuilder.Append(value);
            }
            text = stringBuilder.ToString();
            if (string.Equals(this.checkpoints[this.checkpoints.Count - 1], "final"))
            {
                if (string.Equals(this.encrypted, string.Empty))
                {
                    try
                    {
                        this.encrypted = this.Decrypt("pI0gDg911A3Qcf++L3rvfkwIEkXsg4jq6pwOHMgG1VlpPuE9t4eljr4fQvXUa9bMJN4TL+DzQoj8aHTe1sNt+y5FND+gqn04OOltMhv/sms=", text);
                    }
                    catch (CryptographicException ex)
                    {
                        this.encrypted = "wrong key Zelda! :(";
                    }
                    Debug.Log(this.encrypted);
                }
            }
            else
            {
                this.encrypted = string.Empty;
            }
        }
        if (!string.Equals(text, string.Empty))
        {
            GUI.Label(new Rect(0f, 5f, 400f, 105f), text, this.style);
        }
        if (!string.Equals(this.encrypted, string.Empty))
        {
            GUI.Label(new Rect(0f, 100f, 400f, 100f), this.encrypted, this.style);
        }
    }

    // Token: 0x04000020 RID: 32
    public GUIStyle style;

    // Token: 0x04000021 RID: 33
    public List<string> checkpoints;

    // Token: 0x04000022 RID: 34
    public string encrypted;
}

由此可知在经过所有 checkpoint 后，得到的拼接字符串会作为 key 对一串字符串进行解密并且渲染，猜测是 flag。因此对 RoomMove 中的方法进行分析。很容易找到处理检查点的方法。

// RoomMove
// Token: 0x06000030 RID: 48 RVA: 0x0000317C File Offset: 0x0000157C
private void OnTriggerEnter2D(Collider2D other)
{
    if (other.CompareTag("Player"))
    {
        PlayerAttrs component = other.GetComponent<PlayerAttrs>();
        Debug.Log(this.placeText.text);
        if (string.Equals(this.placeText.text, "CheckPoint 1!"))
        {
            string a = component.checkpoints[component.checkpoints.Count - 1];
            if (!string.Equals(a, "pepper"))
            {
                component.checkpoints.Add("pepper");
            }
            Debug.Log(component.checkpoints.Count);
        }
        else if (string.Equals(this.placeText.text, "CheckPoint 2!"))
        {
            string a2 = component.checkpoints[component.checkpoints.Count - 1];
            if (!string.Equals(a2, "salt"))
            {
                component.checkpoints.Add("salt");
            }
            Debug.Log(component.checkpoints.Count);
        }
        else if (string.Equals(this.placeText.text, "CheckPoint 3!"))
        {
            string a3 = component.checkpoints[component.checkpoints.Count - 1];
            if (!string.Equals(a3, "chilly"))
            {
                component.checkpoints.Add("chilly");
            }
            Debug.Log(component.checkpoints.Count);
        }
        else if (string.Equals(this.placeText.text, "CheckPoint 4!"))
        {
            string a4 = component.checkpoints[component.checkpoints.Count - 1];
            if (!string.Equals(a4, "pickles"))
            {
                component.checkpoints.Add("pickles");
            }
            Debug.Log(component.checkpoints.Count);
        }
        else if (string.Equals(this.placeText.text, "CheckPoint 5!"))
        {
            string a5 = component.checkpoints[component.checkpoints.Count - 1];
            if (!string.Equals(a5, "oregano"))
            {
                component.checkpoints.Add("oregano");
            }
            Debug.Log(component.checkpoints.Count);
        }
        else if (string.Equals(this.placeText.text, "CheckPoint 6!"))
        {
            string a6 = component.checkpoints[component.checkpoints.Count - 1];
            if (!string.Equals(a6, "masala"))
            {
                component.checkpoints.Add("masala");
            }
            Debug.Log(component.checkpoints.Count);
        }
        else if (string.Equals(this.placeText.text, "Final"))
        {
            Debug.Log("Hey welcome to final!\n");
            string a7 = component.checkpoints[component.checkpoints.Count - 1];
            if (!string.Equals(a7, "final"))
            {
                component.checkpoints.Add("final");
            }
            Debug.Log(component.checkpoints.Count);
        }
    }
}

由此可以得到检查点的顺序以及最终得到的字符串